package co.edu.usbcali.unidades.presentation.businessDelegate;

import co.edu.usbcali.unidades.modelo.Administrador;
import co.edu.usbcali.unidades.modelo.Autorizacion;
import co.edu.usbcali.unidades.modelo.Ciudad;
import co.edu.usbcali.unidades.modelo.Concepto;
import co.edu.usbcali.unidades.modelo.Correspondencia;
import co.edu.usbcali.unidades.modelo.Cuenta;
import co.edu.usbcali.unidades.modelo.DetalleCorrespondencia;
import co.edu.usbcali.unidades.modelo.DetalleFactura;
import co.edu.usbcali.unidades.modelo.Division;
import co.edu.usbcali.unidades.modelo.DtoCorrespondencia;
import co.edu.usbcali.unidades.modelo.Estado;
import co.edu.usbcali.unidades.modelo.Factura;
import co.edu.usbcali.unidades.modelo.GrupoFamiliar;
import co.edu.usbcali.unidades.modelo.Inmueble;
import co.edu.usbcali.unidades.modelo.MovMesInmueble;
import co.edu.usbcali.unidades.modelo.Multa;
import co.edu.usbcali.unidades.modelo.Pais;
import co.edu.usbcali.unidades.modelo.Persona;
import co.edu.usbcali.unidades.modelo.Presupuesto;
import co.edu.usbcali.unidades.modelo.PropietarioInmueble;
import co.edu.usbcali.unidades.modelo.Recepcion;
import co.edu.usbcali.unidades.modelo.Reserva;
import co.edu.usbcali.unidades.modelo.Rubro;
import co.edu.usbcali.unidades.modelo.TipoCategoria;
import co.edu.usbcali.unidades.modelo.TipoConcepto;
import co.edu.usbcali.unidades.modelo.TipoCorrespondencia;
import co.edu.usbcali.unidades.modelo.TipoDocumento;
import co.edu.usbcali.unidades.modelo.TipoPersona;
import co.edu.usbcali.unidades.modelo.TipoUsuario;
import co.edu.usbcali.unidades.modelo.TipoVehiculo;
import co.edu.usbcali.unidades.modelo.TipoZonaComun;
import co.edu.usbcali.unidades.modelo.TipoZonaExtra;
import co.edu.usbcali.unidades.modelo.UnidadResidencial;
import co.edu.usbcali.unidades.modelo.Usuario;
import co.edu.usbcali.unidades.modelo.Vehiculo;
import co.edu.usbcali.unidades.modelo.ZonaComun;
import co.edu.usbcali.unidades.modelo.ZonaExtra;
import co.edu.usbcali.unidades.modelo.control.AdministradorLogic;
import co.edu.usbcali.unidades.modelo.control.AutorizacionLogic;
import co.edu.usbcali.unidades.modelo.control.CiudadLogic;
import co.edu.usbcali.unidades.modelo.control.ConceptoLogic;
import co.edu.usbcali.unidades.modelo.control.CorrespondenciaLogic;
import co.edu.usbcali.unidades.modelo.control.CuentaLogic;
import co.edu.usbcali.unidades.modelo.control.DetalleCorrespondenciaLogic;
import co.edu.usbcali.unidades.modelo.control.DetalleFacturaLogic;
import co.edu.usbcali.unidades.modelo.control.DivisionLogic;
import co.edu.usbcali.unidades.modelo.control.EstadoLogic;
import co.edu.usbcali.unidades.modelo.control.FacturaLogic;
import co.edu.usbcali.unidades.modelo.control.GrupoFamiliarLogic;
import co.edu.usbcali.unidades.modelo.control.IAdministradorLogic;
import co.edu.usbcali.unidades.modelo.control.IAutorizacionLogic;
import co.edu.usbcali.unidades.modelo.control.ICiudadLogic;
import co.edu.usbcali.unidades.modelo.control.IConceptoLogic;
import co.edu.usbcali.unidades.modelo.control.ICorrespondenciaLogic;
import co.edu.usbcali.unidades.modelo.control.ICuentaLogic;
import co.edu.usbcali.unidades.modelo.control.IDetalleCorrespondenciaLogic;
import co.edu.usbcali.unidades.modelo.control.IDetalleFacturaLogic;
import co.edu.usbcali.unidades.modelo.control.IDivisionLogic;
import co.edu.usbcali.unidades.modelo.control.IEstadoLogic;
import co.edu.usbcali.unidades.modelo.control.IFacturaLogic;
import co.edu.usbcali.unidades.modelo.control.IGrupoFamiliarLogic;
import co.edu.usbcali.unidades.modelo.control.IInmuebleLogic;
import co.edu.usbcali.unidades.modelo.control.IMovMesInmuebleLogic;
import co.edu.usbcali.unidades.modelo.control.IMultaLogic;
import co.edu.usbcali.unidades.modelo.control.IPaisLogic;
import co.edu.usbcali.unidades.modelo.control.IPersonaLogic;
import co.edu.usbcali.unidades.modelo.control.IPresupuestoLogic;
import co.edu.usbcali.unidades.modelo.control.IPropietarioInmuebleLogic;
import co.edu.usbcali.unidades.modelo.control.IRecepcionLogic;
import co.edu.usbcali.unidades.modelo.control.IReservaLogic;
import co.edu.usbcali.unidades.modelo.control.IRubroLogic;
import co.edu.usbcali.unidades.modelo.control.ITipoCategoriaLogic;
import co.edu.usbcali.unidades.modelo.control.ITipoConceptoLogic;
import co.edu.usbcali.unidades.modelo.control.ITipoCorrespondenciaLogic;
import co.edu.usbcali.unidades.modelo.control.ITipoDocumentoLogic;
import co.edu.usbcali.unidades.modelo.control.ITipoPersonaLogic;
import co.edu.usbcali.unidades.modelo.control.ITipoUsuarioLogic;
import co.edu.usbcali.unidades.modelo.control.ITipoVehiculoLogic;
import co.edu.usbcali.unidades.modelo.control.ITipoZonaComunLogic;
import co.edu.usbcali.unidades.modelo.control.ITipoZonaExtraLogic;
import co.edu.usbcali.unidades.modelo.control.IUnidadResidencialLogic;
import co.edu.usbcali.unidades.modelo.control.IUsuarioLogic;
import co.edu.usbcali.unidades.modelo.control.IVehiculoLogic;
import co.edu.usbcali.unidades.modelo.control.IZonaComunLogic;
import co.edu.usbcali.unidades.modelo.control.IZonaExtraLogic;
import co.edu.usbcali.unidades.modelo.control.InmuebleLogic;
import co.edu.usbcali.unidades.modelo.control.MovMesInmuebleLogic;
import co.edu.usbcali.unidades.modelo.control.MultaLogic;
import co.edu.usbcali.unidades.modelo.control.PaisLogic;
import co.edu.usbcali.unidades.modelo.control.PersonaLogic;
import co.edu.usbcali.unidades.modelo.control.PresupuestoLogic;
import co.edu.usbcali.unidades.modelo.control.PropietarioInmuebleLogic;
import co.edu.usbcali.unidades.modelo.control.RecepcionLogic;
import co.edu.usbcali.unidades.modelo.control.ReservaLogic;
import co.edu.usbcali.unidades.modelo.control.RubroLogic;
import co.edu.usbcali.unidades.modelo.control.TipoCategoriaLogic;
import co.edu.usbcali.unidades.modelo.control.TipoConceptoLogic;
import co.edu.usbcali.unidades.modelo.control.TipoCorrespondenciaLogic;
import co.edu.usbcali.unidades.modelo.control.TipoDocumentoLogic;
import co.edu.usbcali.unidades.modelo.control.TipoPersonaLogic;
import co.edu.usbcali.unidades.modelo.control.TipoUsuarioLogic;
import co.edu.usbcali.unidades.modelo.control.TipoVehiculoLogic;
import co.edu.usbcali.unidades.modelo.control.TipoZonaComunLogic;
import co.edu.usbcali.unidades.modelo.control.TipoZonaExtraLogic;
import co.edu.usbcali.unidades.modelo.control.UnidadResidencialLogic;
import co.edu.usbcali.unidades.modelo.control.UsuarioLogic;
import co.edu.usbcali.unidades.modelo.control.VehiculoLogic;
import co.edu.usbcali.unidades.modelo.control.ZonaComunLogic;
import co.edu.usbcali.unidades.modelo.control.ZonaExtraLogic;

import java.math.BigDecimal;

import java.util.Date;
import java.util.List;
import java.util.Set;


public class BusinessDelegatorView {
	private BusinessDelegatorView() {
	}

	public static List<Administrador> getAdministrador() throws Exception {
		IAdministradorLogic administradorLogic = new AdministradorLogic();

		return administradorLogic.getAdministrador();
	}

	public static void saveAdministrador(String admCodigo,
			String estCodigo_Estado, String perCedula_Persona) throws Exception {
		IAdministradorLogic administradorLogic = new AdministradorLogic();
		administradorLogic.saveAdministrador(admCodigo, estCodigo_Estado,
				perCedula_Persona);
	}

	public static void deleteAdministrador(String admCodigo) throws Exception {
		IAdministradorLogic administradorLogic = new AdministradorLogic();
		administradorLogic.deleteAdministrador(admCodigo);
	}

	public static void updateAdministrador(String admCodigo,
			String estCodigo_Estado, String perCedula_Persona) throws Exception {
		IAdministradorLogic administradorLogic = new AdministradorLogic();
		administradorLogic.updateAdministrador(admCodigo, estCodigo_Estado,
				perCedula_Persona);
	}

	public static Administrador getAdministrador(String admCodigo)
			throws Exception {
		IAdministradorLogic administradorLogic = new AdministradorLogic();
		Administrador administrador = null;

		try {
			administrador = administradorLogic.getAdministrador(admCodigo);
		} catch (Exception e) {
			throw e;
		}

		return administrador;
	}

	public static List<Administrador> findByCriteriaInAdministrador(
			Object[] variables, Object[] variablesBetween,
			Object[] variablesBetweenDates) throws Exception {
		IAdministradorLogic administradorLogic = new AdministradorLogic();

		return administradorLogic.findByCriteria(variables, variablesBetween,
				variablesBetweenDates);
	}

	public static List<Administrador> findPageAdministrador(
			String sortColumnName, boolean sortAscending, int startRow,
			int maxResults) throws Exception {
		IAdministradorLogic administradorLogic = new AdministradorLogic();

		return administradorLogic.findPageAdministrador(sortColumnName,
				sortAscending, startRow, maxResults);
	}

	public static Long findTotalNumberAdministrador() throws Exception {
		IAdministradorLogic administradorLogic = new AdministradorLogic();

		return administradorLogic.findTotalNumberAdministrador();
	}

	public static List<Autorizacion> getAutorizacion() throws Exception {
		IAutorizacionLogic autorizacionLogic = new AutorizacionLogic();
		return autorizacionLogic.getAutorizacion();
	}

	public static void saveAutorizacion(String autCedVisitante,
			String autCodigo, String autDescripcionActi,
			String autDescripcionPermi, String autEmpresa, Date autFecha,
			String autNombreVisitante, String estCodigo_Estado,
			String priCodigo_PropietarioInmueble) throws Exception {
		IAutorizacionLogic autorizacionLogic = new AutorizacionLogic();
		autorizacionLogic.saveAutorizacion(autCedVisitante, autCodigo,
				autDescripcionActi, autDescripcionPermi, autEmpresa, autFecha,
				autNombreVisitante, estCodigo_Estado,
				priCodigo_PropietarioInmueble);
	}

	public static void deleteAutorizacion(String autCodigo) throws Exception {
		IAutorizacionLogic autorizacionLogic = new AutorizacionLogic();
		autorizacionLogic.deleteAutorizacion(autCodigo);
	}

	public static void updateAutorizacion(String autCedVisitante,
			String autCodigo, String autDescripcionActi,
			String autDescripcionPermi, String autEmpresa, Date autFecha,
			String autNombreVisitante, String estCodigo_Estado,
			String priCodigo_PropietarioInmueble) throws Exception {
		IAutorizacionLogic autorizacionLogic = new AutorizacionLogic();
		autorizacionLogic.updateAutorizacion(autCedVisitante, autCodigo,
				autDescripcionActi, autDescripcionPermi, autEmpresa, autFecha,
				autNombreVisitante, estCodigo_Estado,
				priCodigo_PropietarioInmueble);
	}

	public static Autorizacion getAutorizacion(String autCodigo)
			throws Exception {
		IAutorizacionLogic autorizacionLogic = new AutorizacionLogic();
		Autorizacion autorizacion = null;

		try {
			autorizacion = autorizacionLogic.getAutorizacion(autCodigo);
		} catch (Exception e) {
			throw e;
		}

		return autorizacion;
	}

	public static List<Autorizacion> findByCriteriaInAutorizacion(
			Object[] variables, Object[] variablesBetween,
			Object[] variablesBetweenDates) throws Exception {
		IAutorizacionLogic autorizacionLogic = new AutorizacionLogic();

		return autorizacionLogic.findByCriteria(variables, variablesBetween,
				variablesBetweenDates);
	}

	public static List<Autorizacion> findPageAutorizacion(
			String sortColumnName, boolean sortAscending, int startRow,
			int maxResults) throws Exception {
		IAutorizacionLogic autorizacionLogic = new AutorizacionLogic();

		return autorizacionLogic.findPageAutorizacion(sortColumnName,
				sortAscending, startRow, maxResults);
	}

	public static Long findTotalNumberAutorizacion() throws Exception {
		IAutorizacionLogic autorizacionLogic = new AutorizacionLogic();

		return autorizacionLogic.findTotalNumberAutorizacion();
	}

	public static List<Ciudad> getCiudad() throws Exception {
		ICiudadLogic ciudadLogic = new CiudadLogic();

		return ciudadLogic.getCiudad();
	}

	public static void saveCiudad(String ciuCodigo, String ciuNombre,
			String estCodigo_Estado, String paiCodigo_Pais) throws Exception {
		ICiudadLogic ciudadLogic = new CiudadLogic();
		ciudadLogic.saveCiudad(ciuCodigo, ciuNombre, estCodigo_Estado,
				paiCodigo_Pais);
	}

	public static void deleteCiudad(String ciuCodigo) throws Exception {
		ICiudadLogic ciudadLogic = new CiudadLogic();
		ciudadLogic.deleteCiudad(ciuCodigo);
	}

	public static void updateCiudad(String ciuCodigo, String ciuNombre,
			String estCodigo_Estado, String paiCodigo_Pais) throws Exception {
		ICiudadLogic ciudadLogic = new CiudadLogic();
		ciudadLogic.updateCiudad(ciuCodigo, ciuNombre, estCodigo_Estado,
				paiCodigo_Pais);
	}

	public static Ciudad getCiudad(String ciuCodigo) throws Exception {
		ICiudadLogic ciudadLogic = new CiudadLogic();
		Ciudad ciudad = null;

		try {
			ciudad = ciudadLogic.getCiudad(ciuCodigo);
		} catch (Exception e) {
			throw e;
		}

		return ciudad;
	}

	public static List<Ciudad> findByCriteriaInCiudad(Object[] variables,
			Object[] variablesBetween, Object[] variablesBetweenDates)
			throws Exception {
		ICiudadLogic ciudadLogic = new CiudadLogic();

		return ciudadLogic.findByCriteria(variables, variablesBetween,
				variablesBetweenDates);
	}

	public static List<Ciudad> findPageCiudad(String sortColumnName,
			boolean sortAscending, int startRow, int maxResults)
			throws Exception {
		ICiudadLogic ciudadLogic = new CiudadLogic();

		return ciudadLogic.findPageCiudad(sortColumnName, sortAscending,
				startRow, maxResults);
	}

	public static Long findTotalNumberCiudad() throws Exception {
		ICiudadLogic ciudadLogic = new CiudadLogic();

		return ciudadLogic.findTotalNumberCiudad();
	}

	public static List<Concepto> getConcepto() throws Exception {
		IConceptoLogic conceptoLogic = new ConceptoLogic();

		return conceptoLogic.getConcepto();
	}

	public static void saveConcepto(String conCodigo, Long conPorcentajeImpre,
			Float conValor, String preCodigo_Presupuesto,
			String tcaCodigo_TipoCategoria, String tcoCodigo_TipoConcepto)
			throws Exception {
		IConceptoLogic conceptoLogic = new ConceptoLogic();
		conceptoLogic.saveConcepto(conCodigo, conPorcentajeImpre, conValor,
				preCodigo_Presupuesto, tcaCodigo_TipoCategoria,
				tcoCodigo_TipoConcepto);
	}

	public static void deleteConcepto(String conCodigo) throws Exception {
		IConceptoLogic conceptoLogic = new ConceptoLogic();
		conceptoLogic.deleteConcepto(conCodigo);
	}

	public static void updateConcepto(String conCodigo,
			Long conPorcentajeImpre, Float conValor,
			String preCodigo_Presupuesto, String tcaCodigo_TipoCategoria,
			String tcoCodigo_TipoConcepto) throws Exception {
		IConceptoLogic conceptoLogic = new ConceptoLogic();
		conceptoLogic.updateConcepto(conCodigo, conPorcentajeImpre, conValor,
				preCodigo_Presupuesto, tcaCodigo_TipoCategoria,
				tcoCodigo_TipoConcepto);
	}

	public static Concepto getConcepto(String conCodigo) throws Exception {
		IConceptoLogic conceptoLogic = new ConceptoLogic();
		Concepto concepto = null;

		try {
			concepto = conceptoLogic.getConcepto(conCodigo);
		} catch (Exception e) {
			throw e;
		}

		return concepto;
	}

	public static List<Concepto> findByCriteriaInConcepto(Object[] variables,
			Object[] variablesBetween, Object[] variablesBetweenDates)
			throws Exception {
		IConceptoLogic conceptoLogic = new ConceptoLogic();

		return conceptoLogic.findByCriteria(variables, variablesBetween,
				variablesBetweenDates);
	}

	public static List<Concepto> findPageConcepto(String sortColumnName,
			boolean sortAscending, int startRow, int maxResults)
			throws Exception {
		IConceptoLogic conceptoLogic = new ConceptoLogic();

		return conceptoLogic.findPageConcepto(sortColumnName, sortAscending,
				startRow, maxResults);
	}

	public static Long findTotalNumberConcepto() throws Exception {
		IConceptoLogic conceptoLogic = new ConceptoLogic();

		return conceptoLogic.findTotalNumberConcepto();
	}

	public static List<Correspondencia> getCorrespondencia() throws Exception {
		ICorrespondenciaLogic correspondenciaLogic = new CorrespondenciaLogic();

		return correspondenciaLogic.getCorrespondencia();
	}

	public static void saveCorrespondencia(String corAsunto, String corCodigo,
			String tpcCodigo_TipoCorrespondencia) throws Exception {
		ICorrespondenciaLogic correspondenciaLogic = new CorrespondenciaLogic();
		correspondenciaLogic.saveCorrespondencia(corAsunto, corCodigo,
				tpcCodigo_TipoCorrespondencia);
	}

	public static void deleteCorrespondencia(String corCodigo) throws Exception {
		ICorrespondenciaLogic correspondenciaLogic = new CorrespondenciaLogic();
		correspondenciaLogic.deleteCorrespondencia(corCodigo);
	}

	public static void updateCorrespondencia(String corAsunto,
			String corCodigo, String tpcCodigo_TipoCorrespondencia)
			throws Exception {
		ICorrespondenciaLogic correspondenciaLogic = new CorrespondenciaLogic();
		correspondenciaLogic.updateCorrespondencia(corAsunto, corCodigo,
				tpcCodigo_TipoCorrespondencia);
	}

	public static Correspondencia getCorrespondencia(String corCodigo)
			throws Exception {
		ICorrespondenciaLogic correspondenciaLogic = new CorrespondenciaLogic();
		Correspondencia correspondencia = null;

		try {
			correspondencia = correspondenciaLogic
					.getCorrespondencia(corCodigo);
		} catch (Exception e) {
			throw e;
		}

		return correspondencia;
	}

	public static List<Correspondencia> findByCriteriaInCorrespondencia(
			Object[] variables, Object[] variablesBetween,
			Object[] variablesBetweenDates) throws Exception {
		ICorrespondenciaLogic correspondenciaLogic = new CorrespondenciaLogic();

		return correspondenciaLogic.findByCriteria(variables, variablesBetween,
				variablesBetweenDates);
	}

	public static List<Correspondencia> findPageCorrespondencia(
			String sortColumnName, boolean sortAscending, int startRow,
			int maxResults) throws Exception {
		ICorrespondenciaLogic correspondenciaLogic = new CorrespondenciaLogic();

		return correspondenciaLogic.findPageCorrespondencia(sortColumnName,
				sortAscending, startRow, maxResults);
	}

	public static Long findTotalNumberCorrespondencia() throws Exception {
		ICorrespondenciaLogic correspondenciaLogic = new CorrespondenciaLogic();

		return correspondenciaLogic.findTotalNumberCorrespondencia();
	}

	public static List<Cuenta> getCuenta() throws Exception {
		ICuentaLogic cuentaLogic = new CuentaLogic();

		return cuentaLogic.getCuenta();
	}

	public static void saveCuenta(String cueCodCuenta, String estCodigo_Estado,
			String priCodigo_PropietarioInmueble) throws Exception {
		ICuentaLogic cuentaLogic = new CuentaLogic();
		cuentaLogic.saveCuenta(cueCodCuenta, estCodigo_Estado,
				priCodigo_PropietarioInmueble);
	}

	public static void deleteCuenta(String cueCodCuenta) throws Exception {
		ICuentaLogic cuentaLogic = new CuentaLogic();
		cuentaLogic.deleteCuenta(cueCodCuenta);
	}

	public static void updateCuenta(String cueCodCuenta,
			String estCodigo_Estado, String priCodigo_PropietarioInmueble)
			throws Exception {
		ICuentaLogic cuentaLogic = new CuentaLogic();
		cuentaLogic.updateCuenta(cueCodCuenta, estCodigo_Estado,
				priCodigo_PropietarioInmueble);
	}

	public static Cuenta getCuenta(String cueCodCuenta) throws Exception {
		ICuentaLogic cuentaLogic = new CuentaLogic();
		Cuenta cuenta = null;

		try {
			cuenta = cuentaLogic.getCuenta(cueCodCuenta);
		} catch (Exception e) {
			throw e;
		}

		return cuenta;
	}

	public static List<Cuenta> findByCriteriaInCuenta(Object[] variables,
			Object[] variablesBetween, Object[] variablesBetweenDates)
			throws Exception {
		ICuentaLogic cuentaLogic = new CuentaLogic();

		return cuentaLogic.findByCriteria(variables, variablesBetween,
				variablesBetweenDates);
	}

	public static List<Cuenta> findPageCuenta(String sortColumnName,
			boolean sortAscending, int startRow, int maxResults)
			throws Exception {
		ICuentaLogic cuentaLogic = new CuentaLogic();

		return cuentaLogic.findPageCuenta(sortColumnName, sortAscending,
				startRow, maxResults);
	}

	public static Long findTotalNumberCuenta() throws Exception {
		ICuentaLogic cuentaLogic = new CuentaLogic();

		return cuentaLogic.findTotalNumberCuenta();
	}

	public static List<DetalleCorrespondencia> getDetalleCorrespondencia()
			throws Exception {
		IDetalleCorrespondenciaLogic detalleCorrespondenciaLogic = new DetalleCorrespondenciaLogic();

		return detalleCorrespondenciaLogic.getDetalleCorrespondencia();
	}

	public static void saveDetalleCorrespondencia(String dtcCodigo,
			Date dtcFechaEnvio, String corCodigo_Correspondencia,
			String estCodigo_Estado, String perCedula_Persona) throws Exception {
		IDetalleCorrespondenciaLogic detalleCorrespondenciaLogic = new DetalleCorrespondenciaLogic();
		detalleCorrespondenciaLogic.saveDetalleCorrespondencia(dtcCodigo,
				dtcFechaEnvio, corCodigo_Correspondencia, estCodigo_Estado,
				perCedula_Persona);
	}

	public static void deleteDetalleCorrespondencia(String dtcCodigo)
			throws Exception {
		IDetalleCorrespondenciaLogic detalleCorrespondenciaLogic = new DetalleCorrespondenciaLogic();
		detalleCorrespondenciaLogic.deleteDetalleCorrespondencia(dtcCodigo);
	}

	public static void updateDetalleCorrespondencia(String dtcCodigo,
			Date dtcFechaEnvio, String corCodigo_Correspondencia,
			String estCodigo_Estado, String perCedula_Persona) throws Exception {
		IDetalleCorrespondenciaLogic detalleCorrespondenciaLogic = new DetalleCorrespondenciaLogic();
		detalleCorrespondenciaLogic.updateDetalleCorrespondencia(dtcCodigo,
				dtcFechaEnvio, corCodigo_Correspondencia, estCodigo_Estado,
				perCedula_Persona);
	}

	public static DetalleCorrespondencia getDetalleCorrespondencia(
			String dtcCodigo) throws Exception {
		IDetalleCorrespondenciaLogic detalleCorrespondenciaLogic = new DetalleCorrespondenciaLogic();
		DetalleCorrespondencia detalleCorrespondencia = null;

		try {
			detalleCorrespondencia = detalleCorrespondenciaLogic
					.getDetalleCorrespondencia(dtcCodigo);
		} catch (Exception e) {
			throw e;
		}

		return detalleCorrespondencia;
	}

	public static List<DetalleCorrespondencia> findByCriteriaInDetalleCorrespondencia(
			Object[] variables, Object[] variablesBetween,
			Object[] variablesBetweenDates) throws Exception {
		IDetalleCorrespondenciaLogic detalleCorrespondenciaLogic = new DetalleCorrespondenciaLogic();

		return detalleCorrespondenciaLogic.findByCriteria(variables,
				variablesBetween, variablesBetweenDates);
	}

	public static List<DetalleCorrespondencia> findPageDetalleCorrespondencia(
			String sortColumnName, boolean sortAscending, int startRow,
			int maxResults) throws Exception {
		IDetalleCorrespondenciaLogic detalleCorrespondenciaLogic = new DetalleCorrespondenciaLogic();

		return detalleCorrespondenciaLogic.findPageDetalleCorrespondencia(
				sortColumnName, sortAscending, startRow, maxResults);
	}

	public static Long findTotalNumberDetalleCorrespondencia() throws Exception {
		IDetalleCorrespondenciaLogic detalleCorrespondenciaLogic = new DetalleCorrespondenciaLogic();

		return detalleCorrespondenciaLogic
				.findTotalNumberDetalleCorrespondencia();
	}

	public static List<DetalleFactura> getDetalleFactura() throws Exception {
		IDetalleFacturaLogic detalleFacturaLogic = new DetalleFacturaLogic();

		return detalleFacturaLogic.getDetalleFactura();
	}

	public static void saveDetalleFactura(String dtfCodigo, Float dtfValor,
			String facCodigo_Factura, String mviCodigo_MovMesInmueble,
			String rubCodigo_Rubro) throws Exception {
		IDetalleFacturaLogic detalleFacturaLogic = new DetalleFacturaLogic();
		detalleFacturaLogic.saveDetalleFactura(dtfCodigo, dtfValor,
				facCodigo_Factura, mviCodigo_MovMesInmueble, rubCodigo_Rubro);
	}

	public static void deleteDetalleFactura(String dtfCodigo) throws Exception {
		IDetalleFacturaLogic detalleFacturaLogic = new DetalleFacturaLogic();
		detalleFacturaLogic.deleteDetalleFactura(dtfCodigo);
	}

	public static void updateDetalleFactura(String dtfCodigo, Float dtfValor,
			String facCodigo_Factura, String mviCodigo_MovMesInmueble,
			String rubCodigo_Rubro) throws Exception {
		IDetalleFacturaLogic detalleFacturaLogic = new DetalleFacturaLogic();
		detalleFacturaLogic.updateDetalleFactura(dtfCodigo, dtfValor,
				facCodigo_Factura, mviCodigo_MovMesInmueble, rubCodigo_Rubro);
	}

	public static DetalleFactura getDetalleFactura(String dtfCodigo)
			throws Exception {
		IDetalleFacturaLogic detalleFacturaLogic = new DetalleFacturaLogic();
		DetalleFactura detalleFactura = null;

		try {
			detalleFactura = detalleFacturaLogic.getDetalleFactura(dtfCodigo);
		} catch (Exception e) {
			throw e;
		}

		return detalleFactura;
	}

	public static List<DetalleFactura> findByCriteriaInDetalleFactura(
			Object[] variables, Object[] variablesBetween,
			Object[] variablesBetweenDates) throws Exception {
		IDetalleFacturaLogic detalleFacturaLogic = new DetalleFacturaLogic();

		return detalleFacturaLogic.findByCriteria(variables, variablesBetween,
				variablesBetweenDates);
	}

	public static List<DetalleFactura> findPageDetalleFactura(
			String sortColumnName, boolean sortAscending, int startRow,
			int maxResults) throws Exception {
		IDetalleFacturaLogic detalleFacturaLogic = new DetalleFacturaLogic();

		return detalleFacturaLogic.findPageDetalleFactura(sortColumnName,
				sortAscending, startRow, maxResults);
	}

	public static Long findTotalNumberDetalleFactura() throws Exception {
		IDetalleFacturaLogic detalleFacturaLogic = new DetalleFacturaLogic();

		return detalleFacturaLogic.findTotalNumberDetalleFactura();
	}

	public static List<Division> getDivision() throws Exception {
		IDivisionLogic divisionLogic = new DivisionLogic();

		return divisionLogic.getDivision();
	}

	public static void saveDivision(String divCodigo, String divNombre,
			String estCodigo_Estado, String unrNit_UnidadResidencial)
			throws Exception {
		IDivisionLogic divisionLogic = new DivisionLogic();
		divisionLogic.saveDivision(divCodigo, divNombre, estCodigo_Estado,
				unrNit_UnidadResidencial);
	}

	public static void deleteDivision(String divCodigo) throws Exception {
		IDivisionLogic divisionLogic = new DivisionLogic();
		divisionLogic.deleteDivision(divCodigo);
	}

	public static void updateDivision(String divCodigo, String divNombre,
			String estCodigo_Estado, String unrNit_UnidadResidencial)
			throws Exception {
		IDivisionLogic divisionLogic = new DivisionLogic();
		divisionLogic.updateDivision(divCodigo, divNombre, estCodigo_Estado,
				unrNit_UnidadResidencial);
	}

	public static Division getDivision(String divCodigo) throws Exception {
		IDivisionLogic divisionLogic = new DivisionLogic();
		Division division = null;

		try {
			division = divisionLogic.getDivision(divCodigo);
		} catch (Exception e) {
			throw e;
		}

		return division;
	}
	
	public static List<Division> getDivisionUnidad(String unidadNit) throws Exception {
		IDivisionLogic divLOg = new DivisionLogic();
		return divLOg.getDivisionUnidad(unidadNit);
	}

	public static List<Division> findByCriteriaInDivision(Object[] variables,
			Object[] variablesBetween, Object[] variablesBetweenDates)
			throws Exception {
		IDivisionLogic divisionLogic = new DivisionLogic();

		return divisionLogic.findByCriteria(variables, variablesBetween,
				variablesBetweenDates);
	}

	public static List<Division> findPageDivision(String sortColumnName,
			boolean sortAscending, int startRow, int maxResults,
			String uniNombre) throws Exception {
		IDivisionLogic divisionLogic = new DivisionLogic();

		return divisionLogic.findPageDivision(sortColumnName, sortAscending,
				startRow, maxResults, uniNombre);
	}

	public static Long findTotalNumberDivision(String uniNombre)
			throws Exception {
		IDivisionLogic divisionLogic = new DivisionLogic();

		return divisionLogic.findTotalNumberDivision(uniNombre);
	}

	public static List<Estado> getEstado() throws Exception {
		IEstadoLogic estadoLogic = new EstadoLogic();

		return estadoLogic.getEstado();
	}

	public static void saveEstado(String estCodigo, String estNombre)
			throws Exception {
		IEstadoLogic estadoLogic = new EstadoLogic();
		estadoLogic.saveEstado(estCodigo, estNombre);
	}

	public static void deleteEstado(String estCodigo) throws Exception {
		IEstadoLogic estadoLogic = new EstadoLogic();
		estadoLogic.deleteEstado(estCodigo);
	}

	public static void updateEstado(String estCodigo, String estNombre)
			throws Exception {
		IEstadoLogic estadoLogic = new EstadoLogic();
		estadoLogic.updateEstado(estCodigo, estNombre);
	}

	public static Estado getEstado(String estCodigo) throws Exception {
		IEstadoLogic estadoLogic = new EstadoLogic();
		Estado estado = null;

		try {
			estado = estadoLogic.getEstado(estCodigo);
		} catch (Exception e) {
			throw e;
		}

		return estado;
	}

	public static List<Estado> findByCriteriaInEstado(Object[] variables,
			Object[] variablesBetween, Object[] variablesBetweenDates)
			throws Exception {
		IEstadoLogic estadoLogic = new EstadoLogic();

		return estadoLogic.findByCriteria(variables, variablesBetween,
				variablesBetweenDates);
	}

	public static List<Estado> findPageEstado(String sortColumnName,
			boolean sortAscending, int startRow, int maxResults)
			throws Exception {
		IEstadoLogic estadoLogic = new EstadoLogic();

		return estadoLogic.findPageEstado(sortColumnName, sortAscending,
				startRow, maxResults);
	}

	public static Long findTotalNumberEstado() throws Exception {
		IEstadoLogic estadoLogic = new EstadoLogic();

		return estadoLogic.findTotalNumberEstado();
	}

	public static List<Factura> getFactura() throws Exception {
		IFacturaLogic facturaLogic = new FacturaLogic();

		return facturaLogic.getFactura();
	}

	public static void saveFactura(String facCodigo, Date facFecha,
			String cueCodCuenta_Cuenta, String estCodigo_Estado,
			String priCodigo_PropietarioInmueble) throws Exception {
		IFacturaLogic facturaLogic = new FacturaLogic();
		facturaLogic.saveFactura(facCodigo, facFecha, cueCodCuenta_Cuenta,
				estCodigo_Estado, priCodigo_PropietarioInmueble);
	}

	public static void deleteFactura(String facCodigo) throws Exception {
		IFacturaLogic facturaLogic = new FacturaLogic();
		facturaLogic.deleteFactura(facCodigo);
	}

	public static void updateFactura(String facCodigo, Date facFecha,
			String cueCodCuenta_Cuenta, String estCodigo_Estado,
			String priCodigo_PropietarioInmueble) throws Exception {
		IFacturaLogic facturaLogic = new FacturaLogic();
		facturaLogic.updateFactura(facCodigo, facFecha, cueCodCuenta_Cuenta,
				estCodigo_Estado, priCodigo_PropietarioInmueble);
	}

	public static Factura getFactura(String facCodigo) throws Exception {
		IFacturaLogic facturaLogic = new FacturaLogic();
		Factura factura = null;

		try {
			factura = facturaLogic.getFactura(facCodigo);
		} catch (Exception e) {
			throw e;
		}

		return factura;
	}

	public static List<Factura> findByCriteriaInFactura(Object[] variables,
			Object[] variablesBetween, Object[] variablesBetweenDates)
			throws Exception {
		IFacturaLogic facturaLogic = new FacturaLogic();

		return facturaLogic.findByCriteria(variables, variablesBetween,
				variablesBetweenDates);
	}

	public static List<Factura> findPageFactura(String sortColumnName,
			boolean sortAscending, int startRow, int maxResults)
			throws Exception {
		IFacturaLogic facturaLogic = new FacturaLogic();

		return facturaLogic.findPageFactura(sortColumnName, sortAscending,
				startRow, maxResults);
	}

	public static Long findTotalNumberFactura() throws Exception {
		IFacturaLogic facturaLogic = new FacturaLogic();

		return facturaLogic.findTotalNumberFactura();
	}

	public static List<GrupoFamiliar> getGrupoFamiliar() throws Exception {
		IGrupoFamiliarLogic grupoFamiliarLogic = new GrupoFamiliarLogic();

		return grupoFamiliarLogic.getGrupoFamiliar();
	}

	public static void saveGrupoFamiliar(String grfCodigo,
			String estCodigo_Estado, String perCedula_Persona,
			String priCodigo_PropietarioInmueble) throws Exception {
		IGrupoFamiliarLogic grupoFamiliarLogic = new GrupoFamiliarLogic();
		grupoFamiliarLogic.saveGrupoFamiliar(grfCodigo, estCodigo_Estado,
				perCedula_Persona, priCodigo_PropietarioInmueble);
	}

	public static void deleteGrupoFamiliar(String grfCodigo) throws Exception {
		IGrupoFamiliarLogic grupoFamiliarLogic = new GrupoFamiliarLogic();
		grupoFamiliarLogic.deleteGrupoFamiliar(grfCodigo);
	}

	public static void updateGrupoFamiliar(String grfCodigo,
			String estCodigo_Estado, String perCedula_Persona,
			String priCodigo_PropietarioInmueble) throws Exception {
		IGrupoFamiliarLogic grupoFamiliarLogic = new GrupoFamiliarLogic();
		grupoFamiliarLogic.updateGrupoFamiliar(grfCodigo, estCodigo_Estado,
				perCedula_Persona, priCodigo_PropietarioInmueble);
	}

	public static GrupoFamiliar getGrupoFamiliar(String grfCodigo)
			throws Exception {
		IGrupoFamiliarLogic grupoFamiliarLogic = new GrupoFamiliarLogic();
		GrupoFamiliar grupoFamiliar = null;

		try {
			grupoFamiliar = grupoFamiliarLogic.getGrupoFamiliar(grfCodigo);
		} catch (Exception e) {
			throw e;
		}

		return grupoFamiliar;
	}

	public static List<GrupoFamiliar> findByCriteriaInGrupoFamiliar(
			Object[] variables, Object[] variablesBetween,
			Object[] variablesBetweenDates) throws Exception {
		IGrupoFamiliarLogic grupoFamiliarLogic = new GrupoFamiliarLogic();

		return grupoFamiliarLogic.findByCriteria(variables, variablesBetween,
				variablesBetweenDates);
	}

	public static List<GrupoFamiliar> findPageGrupoFamiliar(
			String sortColumnName, boolean sortAscending, int startRow,
			int maxResults) throws Exception {
		IGrupoFamiliarLogic grupoFamiliarLogic = new GrupoFamiliarLogic();

		return grupoFamiliarLogic.findPageGrupoFamiliar(sortColumnName,
				sortAscending, startRow, maxResults);
	}

	public static Long findTotalNumberGrupoFamiliar() throws Exception {
		IGrupoFamiliarLogic grupoFamiliarLogic = new GrupoFamiliarLogic();

		return grupoFamiliarLogic.findTotalNumberGrupoFamiliar();
	}

	public static List<Inmueble> getInmueble() throws Exception {
		IInmuebleLogic inmuebleLogic = new InmuebleLogic();

		return inmuebleLogic.getInmueble();
	}

	public static void saveInmueble(Long inmCuotaAdmin, Long inmDimension,
			String inmNumeroId, String divCodigo_Division,
			String estCodigo_Estado) throws Exception {
		IInmuebleLogic inmuebleLogic = new InmuebleLogic();
		inmuebleLogic.saveInmueble(inmCuotaAdmin, inmDimension, inmNumeroId,
				divCodigo_Division, estCodigo_Estado);
	}

	public static void deleteInmueble(String inmNumeroId) throws Exception {
		IInmuebleLogic inmuebleLogic = new InmuebleLogic();
		inmuebleLogic.deleteInmueble(inmNumeroId);
	}

	public static void updateInmueble(Long inmCuotaAdmin, Long inmDimension,
			String inmNumeroId, String divCodigo_Division,
			String estCodigo_Estado) throws Exception {
		IInmuebleLogic inmuebleLogic = new InmuebleLogic();
		inmuebleLogic.updateInmueble(inmCuotaAdmin, inmDimension, inmNumeroId,
				divCodigo_Division, estCodigo_Estado);
	}

	public static Inmueble getInmueble(String inmNumeroId) throws Exception {
		IInmuebleLogic inmuebleLogic = new InmuebleLogic();
		Inmueble inmueble = null;

		try {
			inmueble = inmuebleLogic.getInmueble(inmNumeroId);
		} catch (Exception e) {
			throw e;
		}

		return inmueble;
	}

	public static List<Inmueble> findByCriteriaInInmueble(Object[] variables,
			Object[] variablesBetween, Object[] variablesBetweenDates)
			throws Exception {
		IInmuebleLogic inmuebleLogic = new InmuebleLogic();

		return inmuebleLogic.findByCriteria(variables, variablesBetween,
				variablesBetweenDates);
	}
	
	public static List<Inmueble> getInmueblesDiv(String divCod) throws Exception{
		IInmuebleLogic inmuebleLogic = new InmuebleLogic();
		return inmuebleLogic.getInmueblesDiv(divCod);
	}

	public static List<Inmueble> findPageInmueble(String sortColumnName,
			boolean sortAscending, int startRow, int maxResults)
			throws Exception {
		IInmuebleLogic inmuebleLogic = new InmuebleLogic();

		return inmuebleLogic.findPageInmueble(sortColumnName, sortAscending,
				startRow, maxResults);
	}

	public static Long findTotalNumberInmueble() throws Exception {
		IInmuebleLogic inmuebleLogic = new InmuebleLogic();

		return inmuebleLogic.findTotalNumberInmueble();
	}

	public static List<MovMesInmueble> getMovMesInmueble() throws Exception {
		IMovMesInmuebleLogic movMesInmuebleLogic = new MovMesInmuebleLogic();

		return movMesInmuebleLogic.getMovMesInmueble();
	}

	public static void saveMovMesInmueble(String mviCodigo, Date mviFecha,
			String inmNumeroId_Inmueble, String mulCodigo_Multa,
			String zocCodigo_ZonaComun, String zneCodigo_ZonaExtra)
			throws Exception {
		IMovMesInmuebleLogic movMesInmuebleLogic = new MovMesInmuebleLogic();
		movMesInmuebleLogic.saveMovMesInmueble(mviCodigo, mviFecha,
				inmNumeroId_Inmueble, mulCodigo_Multa, zocCodigo_ZonaComun,
				zneCodigo_ZonaExtra);
	}

	public static void deleteMovMesInmueble(String mviCodigo) throws Exception {
		IMovMesInmuebleLogic movMesInmuebleLogic = new MovMesInmuebleLogic();
		movMesInmuebleLogic.deleteMovMesInmueble(mviCodigo);
	}

	public static void updateMovMesInmueble(String mviCodigo, Date mviFecha,
			String inmNumeroId_Inmueble, String mulCodigo_Multa,
			String zocCodigo_ZonaComun, String zneCodigo_ZonaExtra)
			throws Exception {
		IMovMesInmuebleLogic movMesInmuebleLogic = new MovMesInmuebleLogic();
		movMesInmuebleLogic.updateMovMesInmueble(mviCodigo, mviFecha,
				inmNumeroId_Inmueble, mulCodigo_Multa, zocCodigo_ZonaComun,
				zneCodigo_ZonaExtra);
	}

	public static MovMesInmueble getMovMesInmueble(String mviCodigo)
			throws Exception {
		IMovMesInmuebleLogic movMesInmuebleLogic = new MovMesInmuebleLogic();
		MovMesInmueble movMesInmueble = null;

		try {
			movMesInmueble = movMesInmuebleLogic.getMovMesInmueble(mviCodigo);
		} catch (Exception e) {
			throw e;
		}

		return movMesInmueble;
	}

	public static List<MovMesInmueble> findByCriteriaInMovMesInmueble(
			Object[] variables, Object[] variablesBetween,
			Object[] variablesBetweenDates) throws Exception {
		IMovMesInmuebleLogic movMesInmuebleLogic = new MovMesInmuebleLogic();

		return movMesInmuebleLogic.findByCriteria(variables, variablesBetween,
				variablesBetweenDates);
	}

	public static List<MovMesInmueble> findPageMovMesInmueble(
			String sortColumnName, boolean sortAscending, int startRow,
			int maxResults) throws Exception {
		IMovMesInmuebleLogic movMesInmuebleLogic = new MovMesInmuebleLogic();

		return movMesInmuebleLogic.findPageMovMesInmueble(sortColumnName,
				sortAscending, startRow, maxResults);
	}

	public static Long findTotalNumberMovMesInmueble() throws Exception {
		IMovMesInmuebleLogic movMesInmuebleLogic = new MovMesInmuebleLogic();

		return movMesInmuebleLogic.findTotalNumberMovMesInmueble();
	}

	public static List<Multa> getMulta() throws Exception {
		IMultaLogic multaLogic = new MultaLogic();

		return multaLogic.getMulta();
	}

	public static void saveMulta(String mulCodigo, Long mulValor,
			String multNombre) throws Exception {
		IMultaLogic multaLogic = new MultaLogic();
		multaLogic.saveMulta(mulCodigo, mulValor, multNombre);
	}

	public static void deleteMulta(String mulCodigo) throws Exception {
		IMultaLogic multaLogic = new MultaLogic();
		multaLogic.deleteMulta(mulCodigo);
	}

	public static void updateMulta(String mulCodigo, Long mulValor,
			String multNombre) throws Exception {
		IMultaLogic multaLogic = new MultaLogic();
		multaLogic.updateMulta(mulCodigo, mulValor, multNombre);
	}

	public static Multa getMulta(String mulCodigo) throws Exception {
		IMultaLogic multaLogic = new MultaLogic();
		Multa multa = null;

		try {
			multa = multaLogic.getMulta(mulCodigo);
		} catch (Exception e) {
			throw e;
		}

		return multa;
	}

	public static List<Multa> findByCriteriaInMulta(Object[] variables,
			Object[] variablesBetween, Object[] variablesBetweenDates)
			throws Exception {
		IMultaLogic multaLogic = new MultaLogic();

		return multaLogic.findByCriteria(variables, variablesBetween,
				variablesBetweenDates);
	}

	public static List<Multa> findPageMulta(String sortColumnName,
			boolean sortAscending, int startRow, int maxResults)
			throws Exception {
		IMultaLogic multaLogic = new MultaLogic();

		return multaLogic.findPageMulta(sortColumnName, sortAscending,
				startRow, maxResults);
	}

	public static Long findTotalNumberMulta() throws Exception {
		IMultaLogic multaLogic = new MultaLogic();

		return multaLogic.findTotalNumberMulta();
	}

	public static List<Pais> getPais() throws Exception {
		IPaisLogic paisLogic = new PaisLogic();

		return paisLogic.getPais();
	}
	
	public static Pais getPaisPorNombre(String paiNombre) throws Exception{
		IPaisLogic paisLogic = new PaisLogic();
		return paisLogic.getPaisPorNombre(paiNombre);
	}
	
	public static List<Pais> getPaisNombreParcial(String paiNombre) throws Exception{
		IPaisLogic paisLogic = new PaisLogic();
		return paisLogic.getPaisNombreParcial(paiNombre);
	}

	public static void savePais(String paiCodigo, String paiNombre,
			String estCodigo_Estado) throws Exception {
		IPaisLogic paisLogic = new PaisLogic();
		paisLogic.savePais(paiCodigo, paiNombre, estCodigo_Estado);
	}

	public static void deletePais(String paiCodigo) throws Exception {
		IPaisLogic paisLogic = new PaisLogic();
		paisLogic.deletePais(paiCodigo);
	}

	public static void updatePais(String paiCodigo, String paiNombre,
			String estCodigo_Estado) throws Exception {
		IPaisLogic paisLogic = new PaisLogic();
		paisLogic.updatePais(paiCodigo, paiNombre, estCodigo_Estado);
	}

	public static Pais getPais(String paiCodigo) throws Exception {
		IPaisLogic paisLogic = new PaisLogic();
		Pais pais = null;

		try {
			pais = paisLogic.getPais(paiCodigo);
		} catch (Exception e) {
			throw e;
		}

		return pais;
	}

	public static List<Pais> findByCriteriaInPais(Object[] variables,
			Object[] variablesBetween, Object[] variablesBetweenDates)
			throws Exception {
		IPaisLogic paisLogic = new PaisLogic();

		return paisLogic.findByCriteria(variables, variablesBetween,
				variablesBetweenDates);
	}

	public static List<Pais> findPagePais(String sortColumnName,
			boolean sortAscending, int startRow, int maxResults)
			throws Exception {
		IPaisLogic paisLogic = new PaisLogic();

		return paisLogic.findPagePais(sortColumnName, sortAscending, startRow,
				maxResults);
	}

	public static Long findTotalNumberPais() throws Exception {
		IPaisLogic paisLogic = new PaisLogic();

		return paisLogic.findTotalNumberPais();
	}

	public static List<Persona> getPersona() throws Exception {
		IPersonaLogic personaLogic = new PersonaLogic();

		return personaLogic.getPersona();
	}

	public static void savePersona(String perCedula, String perCelular,
			String perCorreo, String perPrimerApelli, String perPrimerNom,
			String perSegundoApelli, String perSegundoNom, String perTelefono,
			String estCodigo_Estado, String tipCodigoDoc_TipoDocumento,
			String tipCodigoP_TipoPersona) throws Exception {
		IPersonaLogic personaLogic = new PersonaLogic();
		personaLogic.savePersona(perCedula, perCelular, perCorreo,
				perPrimerApelli, perPrimerNom, perSegundoApelli, perSegundoNom,
				perTelefono, estCodigo_Estado, tipCodigoDoc_TipoDocumento,
				tipCodigoP_TipoPersona);
	}

	public static void savePersonaPropietario(String perCedula,
			String perCelular, String perCorreo, String perPrimerApelli,
			String perPrimerNom, String perSegundoApelli, String perSegundoNom,
			String perTelefono, String estCodigo_Estado,
			String tipCodigoDoc_TipoDocumento, String tipCodigoP_TipoPersona,
			String codLocalizacion, String codInmueble) throws Exception {
			IPersonaLogic personaLogic = new PersonaLogic();
			personaLogic.savePersonaPropietario(perCedula, perCelular, perCorreo,
			perPrimerApelli, perPrimerNom, perSegundoApelli, perSegundoNom,
			perTelefono, estCodigo_Estado, tipCodigoDoc_TipoDocumento,
			tipCodigoP_TipoPersona, codLocalizacion, codInmueble);
	}

	public static void deletePersona(String perCedula, String tpDoc)
			throws Exception {
		IPersonaLogic personaLogic = new PersonaLogic();
		personaLogic.deletePersona(perCedula, tpDoc);
	}

	public static void updatePersonaAdmin(String perCedula, String perCelular,
			String perCorreo, String perPrimerApelli, String perPrimerNom,
			String perSegundoApelli, String perSegundoNom, String perTelefono,
			String estCodigo_Estado, String tipCodigoDoc_TipoDocumento,
			String tipCodigoP_TipoPersona) throws Exception {
		IPersonaLogic personaLogic = new PersonaLogic();
		personaLogic.updatePersonaAdmin(perCedula, perCelular, perCorreo,
				perPrimerApelli, perPrimerNom, perSegundoApelli, perSegundoNom,
				perTelefono, estCodigo_Estado, tipCodigoDoc_TipoDocumento,
				tipCodigoP_TipoPersona);
	}

	public static void updatePersonaPropietario(String perCedula,
			String perCelular, String perCorreo, String perPrimerApelli,
			String perPrimerNom, String perSegundoApelli, String perSegundoNom,
			String perTelefono, String estCodigo_Estado,
			String tipCodigoDoc_TipoDocumento, String tipCodigoP_TipoPersona,
			String codLocalizacion, String codInmueble) throws Exception {
		IPersonaLogic personaLogic = new PersonaLogic();
		personaLogic.updatePersonaPropietario(perCedula, perCelular, perCorreo,
				perPrimerApelli, perPrimerNom, perSegundoApelli, perSegundoNom,
				perTelefono, estCodigo_Estado, tipCodigoDoc_TipoDocumento,
				tipCodigoP_TipoPersona, codLocalizacion, codInmueble);
	}

	public static Persona getPersona(String perCedula) throws Exception {
		IPersonaLogic personaLogic = new PersonaLogic();
		Persona persona = null;

		try {
			persona = personaLogic.getPersona(perCedula);
		} catch (Exception e) {
			throw e;
		}

		return persona;
	}

	public static Persona getPersona2(String perCedula,	String TpDoc) throws Exception {
		IPersonaLogic personaLogic = new PersonaLogic();
		Persona persona = null;

		try {
			persona = personaLogic.getPersona2(perCedula, TpDoc);
		} catch (Exception e) {
			throw e;
		}

		return persona;
	}

	public static List<Persona> findByCriteriaInPersona(Object[] variables,
			Object[] variablesBetween, Object[] variablesBetweenDates)
			throws Exception {
		IPersonaLogic personaLogic = new PersonaLogic();

		return personaLogic.findByCriteria(variables, variablesBetween,
				variablesBetweenDates);
	}

	public static List<Persona> findPagePersona(String sortColumnName,
			boolean sortAscending, int startRow, int maxResults)
			throws Exception {
		IPersonaLogic personaLogic = new PersonaLogic();

		return personaLogic.findPagePersona(sortColumnName, sortAscending,
				startRow, maxResults);
	}

	public static Long findTotalNumberPersona() throws Exception {
		IPersonaLogic personaLogic = new PersonaLogic();

		return personaLogic.findTotalNumberPersona();
	}

	public static List<Presupuesto> getPresupuesto() throws Exception {
		IPresupuestoLogic presupuestoLogic = new PresupuestoLogic();

		return presupuestoLogic.getPresupuesto();
	}

	public static void savePresupuesto(String preCodigo, Date preFecha,
			Float preValorTotal, String estCodigo_Estado,
			String unrNit_UnidadResidencial) throws Exception {
		IPresupuestoLogic presupuestoLogic = new PresupuestoLogic();
		presupuestoLogic.savePresupuesto(preCodigo, preFecha, preValorTotal,
				estCodigo_Estado, unrNit_UnidadResidencial);
	}

	public static void deletePresupuesto(String preCodigo) throws Exception {
		IPresupuestoLogic presupuestoLogic = new PresupuestoLogic();
		presupuestoLogic.deletePresupuesto(preCodigo);
	}

	public static void updatePresupuesto(String preCodigo, Date preFecha,
			Float preValorTotal, String estCodigo_Estado,
			String unrNit_UnidadResidencial) throws Exception {
		IPresupuestoLogic presupuestoLogic = new PresupuestoLogic();
		presupuestoLogic.updatePresupuesto(preCodigo, preFecha, preValorTotal,
				estCodigo_Estado, unrNit_UnidadResidencial);
	}

	public static Presupuesto getPresupuesto(String preCodigo) throws Exception {
		IPresupuestoLogic presupuestoLogic = new PresupuestoLogic();
		Presupuesto presupuesto = null;

		try {
			presupuesto = presupuestoLogic.getPresupuesto(preCodigo);
		} catch (Exception e) {
			throw e;
		}

		return presupuesto;
	}

	public static List<Presupuesto> findByCriteriaInPresupuesto(
			Object[] variables, Object[] variablesBetween,
			Object[] variablesBetweenDates) throws Exception {
		IPresupuestoLogic presupuestoLogic = new PresupuestoLogic();

		return presupuestoLogic.findByCriteria(variables, variablesBetween,
				variablesBetweenDates);
	}

	public static List<Presupuesto> findPagePresupuesto(String sortColumnName,
			boolean sortAscending, int startRow, int maxResults)
			throws Exception {
		IPresupuestoLogic presupuestoLogic = new PresupuestoLogic();

		return presupuestoLogic.findPagePresupuesto(sortColumnName,
				sortAscending, startRow, maxResults);
	}

	public static Long findTotalNumberPresupuesto() throws Exception {
		IPresupuestoLogic presupuestoLogic = new PresupuestoLogic();

		return presupuestoLogic.findTotalNumberPresupuesto();
	}

	public static List<PropietarioInmueble> getPropietarioInmueble()
			throws Exception {
		IPropietarioInmuebleLogic propietarioInmuebleLogic = new PropietarioInmuebleLogic();

		return propietarioInmuebleLogic.getPropietarioInmueble();
	}

	public static void savePropietarioInmueble(String priCodigo,
			String estCodigo_Estado, String inmNumeroId_Inmueble,
			String perCedula_Persona) throws Exception {
		IPropietarioInmuebleLogic propietarioInmuebleLogic = new PropietarioInmuebleLogic();
		propietarioInmuebleLogic.savePropietarioInmueble(priCodigo,
				estCodigo_Estado, inmNumeroId_Inmueble, perCedula_Persona);
	}

	public static void deletePropietarioInmueble(String priCodigo)
			throws Exception {
		IPropietarioInmuebleLogic propietarioInmuebleLogic = new PropietarioInmuebleLogic();
		propietarioInmuebleLogic.deletePropietarioInmueble(priCodigo);
	}

	public static void updatePropietarioInmueble(String priCodigo,
			String estCodigo_Estado, String inmNumeroId_Inmueble,
			String perCedula_Persona) throws Exception {
		IPropietarioInmuebleLogic propietarioInmuebleLogic = new PropietarioInmuebleLogic();
		propietarioInmuebleLogic.updatePropietarioInmueble(priCodigo,
				estCodigo_Estado, inmNumeroId_Inmueble, perCedula_Persona);
	}

	public static PropietarioInmueble getPropietarioInmueble(String priCodigo)
			throws Exception {
		IPropietarioInmuebleLogic propietarioInmuebleLogic = new PropietarioInmuebleLogic();
		PropietarioInmueble propietarioInmueble = null;

		try {
			propietarioInmueble = propietarioInmuebleLogic
					.getPropietarioInmueble(priCodigo);
		} catch (Exception e) {
			throw e;
		}

		return propietarioInmueble;
	}

	public static List<PropietarioInmueble> findByCriteriaInPropietarioInmueble(
			Object[] variables, Object[] variablesBetween,
			Object[] variablesBetweenDates) throws Exception {
		IPropietarioInmuebleLogic propietarioInmuebleLogic = new PropietarioInmuebleLogic();

		return propietarioInmuebleLogic.findByCriteria(variables,
				variablesBetween, variablesBetweenDates);
	}

	public static List<PropietarioInmueble> findPagePropietarioInmueble(
			String sortColumnName, boolean sortAscending, int startRow,
			int maxResults) throws Exception {
		IPropietarioInmuebleLogic propietarioInmuebleLogic = new PropietarioInmuebleLogic();

		return propietarioInmuebleLogic.findPagePropietarioInmueble(
				sortColumnName, sortAscending, startRow, maxResults);
	}

	public static Long findTotalNumberPropietarioInmueble() throws Exception {
		IPropietarioInmuebleLogic propietarioInmuebleLogic = new PropietarioInmuebleLogic();

		return propietarioInmuebleLogic.findTotalNumberPropietarioInmueble();
	}

	public static List<Recepcion> getRecepcion() throws Exception {
		IRecepcionLogic recepcionLogic = new RecepcionLogic();

		return recepcionLogic.getRecepcion();
	}

	public static void saveRecepcion(String observacion,
			String recCodRecepcion, Date recFechaRecepcion,
			String corCodigo_Correspondencia, String usuCodigo_Usuario)
			throws Exception {
		IRecepcionLogic recepcionLogic = new RecepcionLogic();
		recepcionLogic
				.saveRecepcion(observacion, recCodRecepcion, recFechaRecepcion,
						corCodigo_Correspondencia, usuCodigo_Usuario);
	}

	public static void deleteRecepcion(String recCodRecepcion) throws Exception {
		IRecepcionLogic recepcionLogic = new RecepcionLogic();
		recepcionLogic.deleteRecepcion(recCodRecepcion);
	}

	public static void updateRecepcion(String observacion,
			String recCodRecepcion, Date recFechaRecepcion,
			String corCodigo_Correspondencia, String usuCodigo_Usuario)
			throws Exception {
		IRecepcionLogic recepcionLogic = new RecepcionLogic();
		recepcionLogic
				.updateRecepcion(observacion, recCodRecepcion,
						recFechaRecepcion, corCodigo_Correspondencia,
						usuCodigo_Usuario);
	}

	public static Recepcion getRecepcion(String recCodRecepcion)
			throws Exception {
		IRecepcionLogic recepcionLogic = new RecepcionLogic();
		Recepcion recepcion = null;

		try {
			recepcion = recepcionLogic.getRecepcion(recCodRecepcion);
		} catch (Exception e) {
			throw e;
		}

		return recepcion;
	}

	public static List<Recepcion> findByCriteriaInRecepcion(Object[] variables,
			Object[] variablesBetween, Object[] variablesBetweenDates)
			throws Exception {
		IRecepcionLogic recepcionLogic = new RecepcionLogic();

		return recepcionLogic.findByCriteria(variables, variablesBetween,
				variablesBetweenDates);
	}

	public static List<Recepcion> findPageRecepcion(String sortColumnName,
			boolean sortAscending, int startRow, int maxResults)
			throws Exception {
		IRecepcionLogic recepcionLogic = new RecepcionLogic();

		return recepcionLogic.findPageRecepcion(sortColumnName, sortAscending,
				startRow, maxResults);
	}

	public static Long findTotalNumberRecepcion() throws Exception {
		IRecepcionLogic recepcionLogic = new RecepcionLogic();

		return recepcionLogic.findTotalNumberRecepcion();
	}

	public static List<Reserva> getReserva() throws Exception {
		IReservaLogic reservaLogic = new ReservaLogic();

		return reservaLogic.getReserva();
	}

	public static void saveReserva(String resCodigo, Date resFecha,
			Date resHoraFin, Date resHoraInicio, String estCodigo_Estado,
			String priCodigo_PropietarioInmueble, String zocCodigo_ZonaComun)
			throws Exception {
		IReservaLogic reservaLogic = new ReservaLogic();
		reservaLogic.saveReserva(resCodigo, resFecha, resHoraFin,
				resHoraInicio, estCodigo_Estado, priCodigo_PropietarioInmueble,
				zocCodigo_ZonaComun);
	}

	public static void deleteReserva(String resCodigo) throws Exception {
		IReservaLogic reservaLogic = new ReservaLogic();
		reservaLogic.deleteReserva(resCodigo);
	}

	public static void updateReserva(String resCodigo, Date resFecha,
			Date resHoraFin, Date resHoraInicio, String estCodigo_Estado,
			String priCodigo_PropietarioInmueble, String zocCodigo_ZonaComun)
			throws Exception {
		IReservaLogic reservaLogic = new ReservaLogic();
		reservaLogic.updateReserva(resCodigo, resFecha, resHoraFin,
				resHoraInicio, estCodigo_Estado, priCodigo_PropietarioInmueble,
				zocCodigo_ZonaComun);
	}

	public static Reserva getReserva(String resCodigo) throws Exception {
		IReservaLogic reservaLogic = new ReservaLogic();
		Reserva reserva = null;

		try {
			reserva = reservaLogic.getReserva(resCodigo);
		} catch (Exception e) {
			throw e;
		}

		return reserva;
	}

	public static List<Reserva> findByCriteriaInReserva(Object[] variables,
			Object[] variablesBetween, Object[] variablesBetweenDates)
			throws Exception {
		IReservaLogic reservaLogic = new ReservaLogic();

		return reservaLogic.findByCriteria(variables, variablesBetween,
				variablesBetweenDates);
	}

	public static List<Reserva> findPageReserva(String sortColumnName,
			boolean sortAscending, int startRow, int maxResults)
			throws Exception {
		IReservaLogic reservaLogic = new ReservaLogic();

		return reservaLogic.findPageReserva(sortColumnName, sortAscending,
				startRow, maxResults);
	}

	public static Long findTotalNumberReserva() throws Exception {
		IReservaLogic reservaLogic = new ReservaLogic();

		return reservaLogic.findTotalNumberReserva();
	}

	public static List<Rubro> getRubro() throws Exception {
		IRubroLogic rubroLogic = new RubroLogic();

		return rubroLogic.getRubro();
	}

	public static void saveRubro(String rubCodigo, String rubNombre)
			throws Exception {
		IRubroLogic rubroLogic = new RubroLogic();
		rubroLogic.saveRubro(rubCodigo, rubNombre);
	}

	public static void deleteRubro(String rubCodigo) throws Exception {
		IRubroLogic rubroLogic = new RubroLogic();
		rubroLogic.deleteRubro(rubCodigo);
	}

	public static void updateRubro(String rubCodigo, String rubNombre)
			throws Exception {
		IRubroLogic rubroLogic = new RubroLogic();
		rubroLogic.updateRubro(rubCodigo, rubNombre);
	}

	public static Rubro getRubro(String rubCodigo) throws Exception {
		IRubroLogic rubroLogic = new RubroLogic();
		Rubro rubro = null;

		try {
			rubro = rubroLogic.getRubro(rubCodigo);
		} catch (Exception e) {
			throw e;
		}

		return rubro;
	}

	public static List<Rubro> findByCriteriaInRubro(Object[] variables,
			Object[] variablesBetween, Object[] variablesBetweenDates)
			throws Exception {
		IRubroLogic rubroLogic = new RubroLogic();

		return rubroLogic.findByCriteria(variables, variablesBetween,
				variablesBetweenDates);
	}

	public static List<Rubro> findPageRubro(String sortColumnName,
			boolean sortAscending, int startRow, int maxResults)
			throws Exception {
		IRubroLogic rubroLogic = new RubroLogic();

		return rubroLogic.findPageRubro(sortColumnName, sortAscending,
				startRow, maxResults);
	}

	public static Long findTotalNumberRubro() throws Exception {
		IRubroLogic rubroLogic = new RubroLogic();

		return rubroLogic.findTotalNumberRubro();
	}

	public static List<TipoCategoria> getTipoCategoria() throws Exception {
		ITipoCategoriaLogic tipoCategoriaLogic = new TipoCategoriaLogic();

		return tipoCategoriaLogic.getTipoCategoria();
	}

	public static void saveTipoCategoria(String tcaCodigo, String tcaNombre)
			throws Exception {
		ITipoCategoriaLogic tipoCategoriaLogic = new TipoCategoriaLogic();
		tipoCategoriaLogic.saveTipoCategoria(tcaCodigo, tcaNombre);
	}

	public static void deleteTipoCategoria(String tcaCodigo) throws Exception {
		ITipoCategoriaLogic tipoCategoriaLogic = new TipoCategoriaLogic();
		tipoCategoriaLogic.deleteTipoCategoria(tcaCodigo);
	}

	public static void updateTipoCategoria(String tcaCodigo, String tcaNombre)
			throws Exception {
		ITipoCategoriaLogic tipoCategoriaLogic = new TipoCategoriaLogic();
		tipoCategoriaLogic.updateTipoCategoria(tcaCodigo, tcaNombre);
	}

	public static TipoCategoria getTipoCategoria(String tcaCodigo)
			throws Exception {
		ITipoCategoriaLogic tipoCategoriaLogic = new TipoCategoriaLogic();
		TipoCategoria tipoCategoria = null;

		try {
			tipoCategoria = tipoCategoriaLogic.getTipoCategoria(tcaCodigo);
		} catch (Exception e) {
			throw e;
		}

		return tipoCategoria;
	}

	public static List<TipoCategoria> findByCriteriaInTipoCategoria(
			Object[] variables, Object[] variablesBetween,
			Object[] variablesBetweenDates) throws Exception {
		ITipoCategoriaLogic tipoCategoriaLogic = new TipoCategoriaLogic();

		return tipoCategoriaLogic.findByCriteria(variables, variablesBetween,
				variablesBetweenDates);
	}

	public static List<TipoCategoria> findPageTipoCategoria(
			String sortColumnName, boolean sortAscending, int startRow,
			int maxResults) throws Exception {
		ITipoCategoriaLogic tipoCategoriaLogic = new TipoCategoriaLogic();

		return tipoCategoriaLogic.findPageTipoCategoria(sortColumnName,
				sortAscending, startRow, maxResults);
	}

	public static Long findTotalNumberTipoCategoria() throws Exception {
		ITipoCategoriaLogic tipoCategoriaLogic = new TipoCategoriaLogic();

		return tipoCategoriaLogic.findTotalNumberTipoCategoria();
	}

	public static List<TipoConcepto> getTipoConcepto() throws Exception {
		ITipoConceptoLogic tipoConceptoLogic = new TipoConceptoLogic();

		return tipoConceptoLogic.getTipoConcepto();
	}

	public static void saveTipoConcepto(String tcoCodigo, String tcoNombre)
			throws Exception {
		ITipoConceptoLogic tipoConceptoLogic = new TipoConceptoLogic();
		tipoConceptoLogic.saveTipoConcepto(tcoCodigo, tcoNombre);
	}

	public static void deleteTipoConcepto(String tcoCodigo) throws Exception {
		ITipoConceptoLogic tipoConceptoLogic = new TipoConceptoLogic();
		tipoConceptoLogic.deleteTipoConcepto(tcoCodigo);
	}

	public static void updateTipoConcepto(String tcoCodigo, String tcoNombre)
			throws Exception {
		ITipoConceptoLogic tipoConceptoLogic = new TipoConceptoLogic();
		tipoConceptoLogic.updateTipoConcepto(tcoCodigo, tcoNombre);
	}

	public static TipoConcepto getTipoConcepto(String tcoCodigo)
			throws Exception {
		ITipoConceptoLogic tipoConceptoLogic = new TipoConceptoLogic();
		TipoConcepto tipoConcepto = null;

		try {
			tipoConcepto = tipoConceptoLogic.getTipoConcepto(tcoCodigo);
		} catch (Exception e) {
			throw e;
		}

		return tipoConcepto;
	}

	public static List<TipoConcepto> findByCriteriaInTipoConcepto(
			Object[] variables, Object[] variablesBetween,
			Object[] variablesBetweenDates) throws Exception {
		ITipoConceptoLogic tipoConceptoLogic = new TipoConceptoLogic();

		return tipoConceptoLogic.findByCriteria(variables, variablesBetween,
				variablesBetweenDates);
	}

	public static List<TipoConcepto> findPageTipoConcepto(
			String sortColumnName, boolean sortAscending, int startRow,
			int maxResults) throws Exception {
		ITipoConceptoLogic tipoConceptoLogic = new TipoConceptoLogic();

		return tipoConceptoLogic.findPageTipoConcepto(sortColumnName,
				sortAscending, startRow, maxResults);
	}

	public static Long findTotalNumberTipoConcepto() throws Exception {
		ITipoConceptoLogic tipoConceptoLogic = new TipoConceptoLogic();

		return tipoConceptoLogic.findTotalNumberTipoConcepto();
	}

	public static List<TipoCorrespondencia> getTipoCorrespondencia()
			throws Exception {
		ITipoCorrespondenciaLogic tipoCorrespondenciaLogic = new TipoCorrespondenciaLogic();

		return tipoCorrespondenciaLogic.getTipoCorrespondencia();
	}

	public static void saveTipoCorrespondencia(String tpcCodigo,
			String tpcNombre) throws Exception {
		ITipoCorrespondenciaLogic tipoCorrespondenciaLogic = new TipoCorrespondenciaLogic();
		tipoCorrespondenciaLogic.saveTipoCorrespondencia(tpcCodigo, tpcNombre);
	}

	public static void deleteTipoCorrespondencia(String tpcCodigo)
			throws Exception {
		ITipoCorrespondenciaLogic tipoCorrespondenciaLogic = new TipoCorrespondenciaLogic();
		tipoCorrespondenciaLogic.deleteTipoCorrespondencia(tpcCodigo);
	}

	public static void updateTipoCorrespondencia(String tpcCodigo,
			String tpcNombre) throws Exception {
		ITipoCorrespondenciaLogic tipoCorrespondenciaLogic = new TipoCorrespondenciaLogic();
		tipoCorrespondenciaLogic
				.updateTipoCorrespondencia(tpcCodigo, tpcNombre);
	}

	public static TipoCorrespondencia getTipoCorrespondencia(String tpcCodigo)
			throws Exception {
		ITipoCorrespondenciaLogic tipoCorrespondenciaLogic = new TipoCorrespondenciaLogic();
		TipoCorrespondencia tipoCorrespondencia = null;

		try {
			tipoCorrespondencia = tipoCorrespondenciaLogic
					.getTipoCorrespondencia(tpcCodigo);
		} catch (Exception e) {
			throw e;
		}

		return tipoCorrespondencia;
	}

	public static List<TipoCorrespondencia> findByCriteriaInTipoCorrespondencia(
			Object[] variables, Object[] variablesBetween,
			Object[] variablesBetweenDates) throws Exception {
		ITipoCorrespondenciaLogic tipoCorrespondenciaLogic = new TipoCorrespondenciaLogic();

		return tipoCorrespondenciaLogic.findByCriteria(variables,
				variablesBetween, variablesBetweenDates);
	}

	public static List<TipoCorrespondencia> findPageTipoCorrespondencia(
			String sortColumnName, boolean sortAscending, int startRow,
			int maxResults) throws Exception {
		ITipoCorrespondenciaLogic tipoCorrespondenciaLogic = new TipoCorrespondenciaLogic();

		return tipoCorrespondenciaLogic.findPageTipoCorrespondencia(
				sortColumnName, sortAscending, startRow, maxResults);
	}

	public static Long findTotalNumberTipoCorrespondencia() throws Exception {
		ITipoCorrespondenciaLogic tipoCorrespondenciaLogic = new TipoCorrespondenciaLogic();

		return tipoCorrespondenciaLogic.findTotalNumberTipoCorrespondencia();
	}

	public static List<TipoDocumento> getTipoDocumento() throws Exception {
		ITipoDocumentoLogic tipoDocumentoLogic = new TipoDocumentoLogic();

		return tipoDocumentoLogic.getTipoDocumento();
	}

	public static void saveTipoDocumento(String tipCodigoDoc,
			String tipNombreDoc) throws Exception {
		ITipoDocumentoLogic tipoDocumentoLogic = new TipoDocumentoLogic();
		tipoDocumentoLogic.saveTipoDocumento(tipCodigoDoc, tipNombreDoc);
	}

	public static void deleteTipoDocumento(String tipCodigoDoc)
			throws Exception {
		ITipoDocumentoLogic tipoDocumentoLogic = new TipoDocumentoLogic();
		tipoDocumentoLogic.deleteTipoDocumento(tipCodigoDoc);
	}

	public static void updateTipoDocumento(String tipCodigoDoc,
			String tipNombreDoc) throws Exception {
		ITipoDocumentoLogic tipoDocumentoLogic = new TipoDocumentoLogic();
		tipoDocumentoLogic.updateTipoDocumento(tipCodigoDoc, tipNombreDoc);
	}

	public static TipoDocumento getTipoDocumento(String tipCodigoDoc)
			throws Exception {
		ITipoDocumentoLogic tipoDocumentoLogic = new TipoDocumentoLogic();
		TipoDocumento tipoDocumento = null;

		try {
			tipoDocumento = tipoDocumentoLogic.getTipoDocumento(tipCodigoDoc);
		} catch (Exception e) {
			throw e;
		}

		return tipoDocumento;
	}

	public static List<TipoDocumento> findByCriteriaInTipoDocumento(
			Object[] variables, Object[] variablesBetween,
			Object[] variablesBetweenDates) throws Exception {
		ITipoDocumentoLogic tipoDocumentoLogic = new TipoDocumentoLogic();

		return tipoDocumentoLogic.findByCriteria(variables, variablesBetween,
				variablesBetweenDates);
	}

	public static List<TipoDocumento> findPageTipoDocumento(
			String sortColumnName, boolean sortAscending, int startRow,
			int maxResults) throws Exception {
		ITipoDocumentoLogic tipoDocumentoLogic = new TipoDocumentoLogic();

		return tipoDocumentoLogic.findPageTipoDocumento(sortColumnName,
				sortAscending, startRow, maxResults);
	}

	public static Long findTotalNumberTipoDocumento() throws Exception {
		ITipoDocumentoLogic tipoDocumentoLogic = new TipoDocumentoLogic();

		return tipoDocumentoLogic.findTotalNumberTipoDocumento();
	}

	public static List<TipoPersona> getTipoPersona() throws Exception {
		ITipoPersonaLogic tipoPersonaLogic = new TipoPersonaLogic();

		return tipoPersonaLogic.getTipoPersona();
	}

	public static void saveTipoPersona(String tipCodigoP, String tipNombreP)
			throws Exception {
		ITipoPersonaLogic tipoPersonaLogic = new TipoPersonaLogic();
		tipoPersonaLogic.saveTipoPersona(tipCodigoP, tipNombreP);
	}

	public static void deleteTipoPersona(String tipCodigoP) throws Exception {
		ITipoPersonaLogic tipoPersonaLogic = new TipoPersonaLogic();
		tipoPersonaLogic.deleteTipoPersona(tipCodigoP);
	}

	public static void updateTipoPersona(String tipCodigoP, String tipNombreP)
			throws Exception {
		ITipoPersonaLogic tipoPersonaLogic = new TipoPersonaLogic();
		tipoPersonaLogic.updateTipoPersona(tipCodigoP, tipNombreP);
	}

	public static TipoPersona getTipoPersona(String tipCodigoP)
			throws Exception {
		ITipoPersonaLogic tipoPersonaLogic = new TipoPersonaLogic();
		TipoPersona tipoPersona = null;

		try {
			tipoPersona = tipoPersonaLogic.getTipoPersona(tipCodigoP);
		} catch (Exception e) {
			throw e;
		}

		return tipoPersona;
	}

	public static List<TipoPersona> findByCriteriaInTipoPersona(
			Object[] variables, Object[] variablesBetween,
			Object[] variablesBetweenDates) throws Exception {
		ITipoPersonaLogic tipoPersonaLogic = new TipoPersonaLogic();

		return tipoPersonaLogic.findByCriteria(variables, variablesBetween,
				variablesBetweenDates);
	}

	public static List<TipoPersona> findPageTipoPersona(String sortColumnName,
			boolean sortAscending, int startRow, int maxResults)
			throws Exception {
		ITipoPersonaLogic tipoPersonaLogic = new TipoPersonaLogic();

		return tipoPersonaLogic.findPageTipoPersona(sortColumnName,
				sortAscending, startRow, maxResults);
	}

	public static Long findTotalNumberTipoPersona() throws Exception {
		ITipoPersonaLogic tipoPersonaLogic = new TipoPersonaLogic();

		return tipoPersonaLogic.findTotalNumberTipoPersona();
	}

	public static List<TipoUsuario> getTipoUsuario() throws Exception {
		ITipoUsuarioLogic tipoUsuarioLogic = new TipoUsuarioLogic();

		return tipoUsuarioLogic.getTipoUsuario();
	}

	public static void saveTipoUsuario(String tpuCodigo, String tpuNombre)
			throws Exception {
		ITipoUsuarioLogic tipoUsuarioLogic = new TipoUsuarioLogic();
		tipoUsuarioLogic.saveTipoUsuario(tpuCodigo, tpuNombre);
	}

	public static void deleteTipoUsuario(String tpuCodigo) throws Exception {
		ITipoUsuarioLogic tipoUsuarioLogic = new TipoUsuarioLogic();
		tipoUsuarioLogic.deleteTipoUsuario(tpuCodigo);
	}

	public static void updateTipoUsuario(String tpuCodigo, String tpuNombre)
			throws Exception {
		ITipoUsuarioLogic tipoUsuarioLogic = new TipoUsuarioLogic();
		tipoUsuarioLogic.updateTipoUsuario(tpuCodigo, tpuNombre);
	}

	public static TipoUsuario getTipoUsuario(String tpuCodigo) throws Exception {
		ITipoUsuarioLogic tipoUsuarioLogic = new TipoUsuarioLogic();
		TipoUsuario tipoUsuario = null;

		try {
			tipoUsuario = tipoUsuarioLogic.getTipoUsuario(tpuCodigo);
		} catch (Exception e) {
			throw e;
		}

		return tipoUsuario;
	}

	public static List<TipoUsuario> findByCriteriaInTipoUsuario(
			Object[] variables, Object[] variablesBetween,
			Object[] variablesBetweenDates) throws Exception {
		ITipoUsuarioLogic tipoUsuarioLogic = new TipoUsuarioLogic();

		return tipoUsuarioLogic.findByCriteria(variables, variablesBetween,
				variablesBetweenDates);
	}

	public static List<TipoUsuario> findPageTipoUsuario(String sortColumnName,
			boolean sortAscending, int startRow, int maxResults)
			throws Exception {
		ITipoUsuarioLogic tipoUsuarioLogic = new TipoUsuarioLogic();

		return tipoUsuarioLogic.findPageTipoUsuario(sortColumnName,
				sortAscending, startRow, maxResults);
	}

	public static Long findTotalNumberTipoUsuario() throws Exception {
		ITipoUsuarioLogic tipoUsuarioLogic = new TipoUsuarioLogic();

		return tipoUsuarioLogic.findTotalNumberTipoUsuario();
	}

	public static List<TipoVehiculo> getTipoVehiculo() throws Exception {
		ITipoVehiculoLogic tipoVehiculoLogic = new TipoVehiculoLogic();

		return tipoVehiculoLogic.getTipoVehiculo();
	}

	public static void saveTipoVehiculo(String tpvCodigo, String tpvNombre)
			throws Exception {
		ITipoVehiculoLogic tipoVehiculoLogic = new TipoVehiculoLogic();
		tipoVehiculoLogic.saveTipoVehiculo(tpvCodigo, tpvNombre);
	}

	public static void deleteTipoVehiculo(String tpvCodigo) throws Exception {
		ITipoVehiculoLogic tipoVehiculoLogic = new TipoVehiculoLogic();
		tipoVehiculoLogic.deleteTipoVehiculo(tpvCodigo);
	}

	public static void updateTipoVehiculo(String tpvCodigo, String tpvNombre)
			throws Exception {
		ITipoVehiculoLogic tipoVehiculoLogic = new TipoVehiculoLogic();
		tipoVehiculoLogic.updateTipoVehiculo(tpvCodigo, tpvNombre);
	}

	public static TipoVehiculo getTipoVehiculo(String tpvCodigo)
			throws Exception {
		ITipoVehiculoLogic tipoVehiculoLogic = new TipoVehiculoLogic();
		TipoVehiculo tipoVehiculo = null;

		try {
			tipoVehiculo = tipoVehiculoLogic.getTipoVehiculo(tpvCodigo);
		} catch (Exception e) {
			throw e;
		}

		return tipoVehiculo;
	}

	public static List<TipoVehiculo> findByCriteriaInTipoVehiculo(
			Object[] variables, Object[] variablesBetween,
			Object[] variablesBetweenDates) throws Exception {
		ITipoVehiculoLogic tipoVehiculoLogic = new TipoVehiculoLogic();

		return tipoVehiculoLogic.findByCriteria(variables, variablesBetween,
				variablesBetweenDates);
	}

	public static List<TipoVehiculo> findPageTipoVehiculo(
			String sortColumnName, boolean sortAscending, int startRow,
			int maxResults) throws Exception {
		ITipoVehiculoLogic tipoVehiculoLogic = new TipoVehiculoLogic();

		return tipoVehiculoLogic.findPageTipoVehiculo(sortColumnName,
				sortAscending, startRow, maxResults);
	}

	public static Long findTotalNumberTipoVehiculo() throws Exception {
		ITipoVehiculoLogic tipoVehiculoLogic = new TipoVehiculoLogic();

		return tipoVehiculoLogic.findTotalNumberTipoVehiculo();
	}

	public static List<TipoZonaComun> getTipoZonaComun() throws Exception {
		ITipoZonaComunLogic tipoZonaComunLogic = new TipoZonaComunLogic();

		return tipoZonaComunLogic.getTipoZonaComun();
	}

	public static void saveTipoZonaComun(String tzcCodigo, String tzcNombre)
			throws Exception {
		ITipoZonaComunLogic tipoZonaComunLogic = new TipoZonaComunLogic();
		tipoZonaComunLogic.saveTipoZonaComun(tzcCodigo, tzcNombre);
	}

	public static void deleteTipoZonaComun(String tzcCodigo) throws Exception {
		ITipoZonaComunLogic tipoZonaComunLogic = new TipoZonaComunLogic();
		tipoZonaComunLogic.deleteTipoZonaComun(tzcCodigo);
	}

	public static void updateTipoZonaComun(String tzcCodigo, String tzcNombre)
			throws Exception {
		ITipoZonaComunLogic tipoZonaComunLogic = new TipoZonaComunLogic();
		tipoZonaComunLogic.updateTipoZonaComun(tzcCodigo, tzcNombre);
	}

	public static TipoZonaComun getTipoZonaComun(String tzcCodigo)
			throws Exception {
		ITipoZonaComunLogic tipoZonaComunLogic = new TipoZonaComunLogic();
		TipoZonaComun tipoZonaComun = null;

		try {
			tipoZonaComun = tipoZonaComunLogic.getTipoZonaComun(tzcCodigo);
		} catch (Exception e) {
			throw e;
		}

		return tipoZonaComun;
	}

	public static List<TipoZonaComun> findByCriteriaInTipoZonaComun(
			Object[] variables, Object[] variablesBetween,
			Object[] variablesBetweenDates) throws Exception {
		ITipoZonaComunLogic tipoZonaComunLogic = new TipoZonaComunLogic();

		return tipoZonaComunLogic.findByCriteria(variables, variablesBetween,
				variablesBetweenDates);
	}

	public static List<TipoZonaComun> findPageTipoZonaComun(
			String sortColumnName, boolean sortAscending, int startRow,
			int maxResults) throws Exception {
		ITipoZonaComunLogic tipoZonaComunLogic = new TipoZonaComunLogic();

		return tipoZonaComunLogic.findPageTipoZonaComun(sortColumnName,
				sortAscending, startRow, maxResults);
	}

	public static Long findTotalNumberTipoZonaComun() throws Exception {
		ITipoZonaComunLogic tipoZonaComunLogic = new TipoZonaComunLogic();

		return tipoZonaComunLogic.findTotalNumberTipoZonaComun();
	}

	public static List<TipoZonaExtra> getTipoZonaExtra() throws Exception {
		ITipoZonaExtraLogic tipoZonaExtraLogic = new TipoZonaExtraLogic();

		return tipoZonaExtraLogic.getTipoZonaExtra();
	}

	public static void saveTipoZonaExtra(String tzeCodigo, String tzeNombre)
			throws Exception {
		ITipoZonaExtraLogic tipoZonaExtraLogic = new TipoZonaExtraLogic();
		tipoZonaExtraLogic.saveTipoZonaExtra(tzeCodigo, tzeNombre);
	}

	public static void deleteTipoZonaExtra(String tzeCodigo) throws Exception {
		ITipoZonaExtraLogic tipoZonaExtraLogic = new TipoZonaExtraLogic();
		tipoZonaExtraLogic.deleteTipoZonaExtra(tzeCodigo);
	}

	public static void updateTipoZonaExtra(String tzeCodigo, String tzeNombre)
			throws Exception {
		ITipoZonaExtraLogic tipoZonaExtraLogic = new TipoZonaExtraLogic();
		tipoZonaExtraLogic.updateTipoZonaExtra(tzeCodigo, tzeNombre);
	}

	public static TipoZonaExtra getTipoZonaExtra(String tzeCodigo)
			throws Exception {
		ITipoZonaExtraLogic tipoZonaExtraLogic = new TipoZonaExtraLogic();
		TipoZonaExtra tipoZonaExtra = null;

		try {
			tipoZonaExtra = tipoZonaExtraLogic.getTipoZonaExtra(tzeCodigo);
		} catch (Exception e) {
			throw e;
		}

		return tipoZonaExtra;
	}

	public static List<TipoZonaExtra> findByCriteriaInTipoZonaExtra(
			Object[] variables, Object[] variablesBetween,
			Object[] variablesBetweenDates) throws Exception {
		ITipoZonaExtraLogic tipoZonaExtraLogic = new TipoZonaExtraLogic();

		return tipoZonaExtraLogic.findByCriteria(variables, variablesBetween,
				variablesBetweenDates);
	}

	public static List<TipoZonaExtra> findPageTipoZonaExtra(
			String sortColumnName, boolean sortAscending, int startRow,
			int maxResults) throws Exception {
		ITipoZonaExtraLogic tipoZonaExtraLogic = new TipoZonaExtraLogic();

		return tipoZonaExtraLogic.findPageTipoZonaExtra(sortColumnName,
				sortAscending, startRow, maxResults);
	}

	public static Long findTotalNumberTipoZonaExtra() throws Exception {
		ITipoZonaExtraLogic tipoZonaExtraLogic = new TipoZonaExtraLogic();

		return tipoZonaExtraLogic.findTotalNumberTipoZonaExtra();
	}

	public static List<UnidadResidencial> getUnidadResidencial()
			throws Exception {
		IUnidadResidencialLogic unidadResidencialLogic = new UnidadResidencialLogic();

		return unidadResidencialLogic.getUnidadResidencial();
	}
	
	public static List<Persona> getAdminNombreParcial(String nombreParcial)throws Exception{
		IPersonaLogic perLog = new PersonaLogic();
		return perLog.getAdminNombreParcial(nombreParcial);
	}

	public static void saveUnidadResidencial(String unrBarrio,
			String unrDireccion, String unrNit, String unrNombre,
			String unrTelefono, String admCodigo_Administrador,
			String ciuCodigo_Ciudad, String estCodigo_Estado) throws Exception {
		IUnidadResidencialLogic unidadResidencialLogic = new UnidadResidencialLogic();
		unidadResidencialLogic.saveUnidadResidencial(unrBarrio, unrDireccion,
				unrNit, unrNombre, unrTelefono, admCodigo_Administrador,
				ciuCodigo_Ciudad, estCodigo_Estado);
	}

	public static void deleteUnidadResidencial(String unrNit) throws Exception {
		IUnidadResidencialLogic unidadResidencialLogic = new UnidadResidencialLogic();
		unidadResidencialLogic.deleteUnidadResidencial(unrNit);
	}

	public static void updateUnidadResidencial(String unrBarrio,
			String unrDireccion, String unrNit, String unrNombre,
			String unrTelefono, String admCodigo_Administrador,
			String ciuCodigo_Ciudad, String estCodigo_Estado) throws Exception {
		IUnidadResidencialLogic unidadResidencialLogic = new UnidadResidencialLogic();
		unidadResidencialLogic.updateUnidadResidencial(unrBarrio, unrDireccion,
				unrNit, unrNombre, unrTelefono, admCodigo_Administrador,
				ciuCodigo_Ciudad, estCodigo_Estado);
	}

	public static UnidadResidencial getUnidadResidencial(String unrNit)
			throws Exception {
		IUnidadResidencialLogic unidadResidencialLogic = new UnidadResidencialLogic();
		UnidadResidencial unidadResidencial = null;

		try {
			unidadResidencial = unidadResidencialLogic
					.getUnidadResidencial(unrNit);
		} catch (Exception e) {
			throw e;
		}

		return unidadResidencial;
	}

	public static List<UnidadResidencial> findByCriteriaInUnidadResidencial(
			Object[] variables, Object[] variablesBetween,
			Object[] variablesBetweenDates) throws Exception {
		IUnidadResidencialLogic unidadResidencialLogic = new UnidadResidencialLogic();

		return unidadResidencialLogic.findByCriteria(variables,
				variablesBetween, variablesBetweenDates);
	}

	public static List<UnidadResidencial> findPageUnidadResidencial(
			String sortColumnName, boolean sortAscending, int startRow,
			int maxResults) throws Exception {
		IUnidadResidencialLogic unidadResidencialLogic = new UnidadResidencialLogic();

		return unidadResidencialLogic.findPageUnidadResidencial(sortColumnName,
				sortAscending, startRow, maxResults);
	}

	public static Long findTotalNumberUnidadResidencial() throws Exception {
		IUnidadResidencialLogic unidadResidencialLogic = new UnidadResidencialLogic();

		return unidadResidencialLogic.findTotalNumberUnidadResidencial();
	}

	public static List<Usuario> getUsuario() throws Exception {
		IUsuarioLogic usuarioLogic = new UsuarioLogic();

		return usuarioLogic.getUsuario();
	}

	public static void saveUsuario(String usuCodigo, String usuContrasena,
			String usuLogin, String estCodigo_Estado, String perCedula_Persona,
			String tpuCodigo_TipoUsuario) throws Exception {
		IUsuarioLogic usuarioLogic = new UsuarioLogic();
		usuarioLogic.saveUsuario(usuCodigo, usuContrasena, usuLogin,
				estCodigo_Estado, perCedula_Persona, tpuCodigo_TipoUsuario);
	}

	public static void deleteUsuario(String usuCodigo) throws Exception {
		IUsuarioLogic usuarioLogic = new UsuarioLogic();
		usuarioLogic.deleteUsuario(usuCodigo);
	}

	public static void updateUsuario(String usuCodigo, String usuContrasena,
			String usuLogin, String estCodigo_Estado, String perCedula_Persona,
			String tpuCodigo_TipoUsuario) throws Exception {
		IUsuarioLogic usuarioLogic = new UsuarioLogic();
		usuarioLogic.updateUsuario(usuCodigo, usuContrasena, usuLogin,
				estCodigo_Estado, perCedula_Persona, tpuCodigo_TipoUsuario);
	}

	public static Usuario getUsuario(String usuCodigo) throws Exception {
		IUsuarioLogic usuarioLogic = new UsuarioLogic();
		Usuario usuario = null;

		try {
			usuario = usuarioLogic.getUsuario(usuCodigo);
		} catch (Exception e) {
			throw e;
		}

		return usuario;
	}

	public static List<Usuario> findByCriteriaInUsuario(Object[] variables,
			Object[] variablesBetween, Object[] variablesBetweenDates)
			throws Exception {
		IUsuarioLogic usuarioLogic = new UsuarioLogic();

		return usuarioLogic.findByCriteria(variables, variablesBetween,
				variablesBetweenDates);
	}

	public static List<Usuario> findPageUsuario(String sortColumnName,
			boolean sortAscending, int startRow, int maxResults)
			throws Exception {
		IUsuarioLogic usuarioLogic = new UsuarioLogic();

		return usuarioLogic.findPageUsuario(sortColumnName, sortAscending,
				startRow, maxResults);
	}

	public static Long findTotalNumberUsuario() throws Exception {
		IUsuarioLogic usuarioLogic = new UsuarioLogic();

		return usuarioLogic.findTotalNumberUsuario();
	}

	public static List<Vehiculo> getVehiculo() throws Exception {
		IVehiculoLogic vehiculoLogic = new VehiculoLogic();

		return vehiculoLogic.getVehiculo();
	}

	public static void saveVehiculo(Date veiAno, String veiCodigo,
			String veiColor, String veiMarca, String estCodigo_Estado,
			String perCedula_Persona, String tpvCodigo_TipoVehiculo)
			throws Exception {
		IVehiculoLogic vehiculoLogic = new VehiculoLogic();
		vehiculoLogic.saveVehiculo(veiAno, veiCodigo, veiColor, veiMarca,
				estCodigo_Estado, perCedula_Persona, tpvCodigo_TipoVehiculo);
	}

	public static void deleteVehiculo(String veiCodigo) throws Exception {
		IVehiculoLogic vehiculoLogic = new VehiculoLogic();
		vehiculoLogic.deleteVehiculo(veiCodigo);
	}

	public static void updateVehiculo(Date veiAno, String veiCodigo,
			String veiColor, String veiMarca, String estCodigo_Estado,
			String perCedula_Persona, String tpvCodigo_TipoVehiculo)
			throws Exception {
		IVehiculoLogic vehiculoLogic = new VehiculoLogic();
		vehiculoLogic.updateVehiculo(veiAno, veiCodigo, veiColor, veiMarca,
				estCodigo_Estado, perCedula_Persona, tpvCodigo_TipoVehiculo);
	}

	public static Vehiculo getVehiculo(String veiCodigo) throws Exception {
		IVehiculoLogic vehiculoLogic = new VehiculoLogic();
		Vehiculo vehiculo = null;

		try {
			vehiculo = vehiculoLogic.getVehiculo(veiCodigo);
		} catch (Exception e) {
			throw e;
		}

		return vehiculo;
	}

	public static List<Vehiculo> findByCriteriaInVehiculo(Object[] variables,
			Object[] variablesBetween, Object[] variablesBetweenDates)
			throws Exception {
		IVehiculoLogic vehiculoLogic = new VehiculoLogic();

		return vehiculoLogic.findByCriteria(variables, variablesBetween,
				variablesBetweenDates);
	}

	public static List<Vehiculo> findPageVehiculo(String sortColumnName,
			boolean sortAscending, int startRow, int maxResults)
			throws Exception {
		IVehiculoLogic vehiculoLogic = new VehiculoLogic();

		return vehiculoLogic.findPageVehiculo(sortColumnName, sortAscending,
				startRow, maxResults);
	}

	public static Long findTotalNumberVehiculo() throws Exception {
		IVehiculoLogic vehiculoLogic = new VehiculoLogic();

		return vehiculoLogic.findTotalNumberVehiculo();
	}

	public static List<ZonaComun> getZonaComun() throws Exception {
		IZonaComunLogic zonaComunLogic = new ZonaComunLogic();

		return zonaComunLogic.getZonaComun();
	}

	public static void saveZonaComun(String zocCodigo, String zocNombre,
			Long zocValor, String estCodigo_Estado,
			String tzcCodigo_TipoZonaComun, String unrNit_UnidadResidencial)
			throws Exception {
		IZonaComunLogic zonaComunLogic = new ZonaComunLogic();
		zonaComunLogic.saveZonaComun(zocCodigo, zocNombre, zocValor,
				estCodigo_Estado, tzcCodigo_TipoZonaComun,
				unrNit_UnidadResidencial);
	}

	public static void deleteZonaComun(String zocCodigo) throws Exception {
		IZonaComunLogic zonaComunLogic = new ZonaComunLogic();
		zonaComunLogic.deleteZonaComun(zocCodigo);
	}

	public static void updateZonaComun(String zocCodigo, String zocNombre,
			Long zocValor, String estCodigo_Estado,
			String tzcCodigo_TipoZonaComun, String unrNit_UnidadResidencial)
			throws Exception {
		IZonaComunLogic zonaComunLogic = new ZonaComunLogic();
		zonaComunLogic.updateZonaComun(zocCodigo, zocNombre, zocValor,
				estCodigo_Estado, tzcCodigo_TipoZonaComun,
				unrNit_UnidadResidencial);
	}

	public static ZonaComun getZonaComun(String zocCodigo) throws Exception {
		IZonaComunLogic zonaComunLogic = new ZonaComunLogic();
		ZonaComun zonaComun = null;

		try {
			zonaComun = zonaComunLogic.getZonaComun(zocCodigo);
		} catch (Exception e) {
			throw e;
		}

		return zonaComun;
	}

	public static List<ZonaComun> findByCriteriaInZonaComun(Object[] variables,
			Object[] variablesBetween, Object[] variablesBetweenDates)
			throws Exception {
		IZonaComunLogic zonaComunLogic = new ZonaComunLogic();

		return zonaComunLogic.findByCriteria(variables, variablesBetween,
				variablesBetweenDates);
	}

	public static List<ZonaComun> findPageZonaComun(String sortColumnName,
			boolean sortAscending, int startRow, int maxResults)
			throws Exception {
		IZonaComunLogic zonaComunLogic = new ZonaComunLogic();

		return zonaComunLogic.findPageZonaComun(sortColumnName, sortAscending,
				startRow, maxResults);
	}

	public static Long findTotalNumberZonaComun() throws Exception {
		IZonaComunLogic zonaComunLogic = new ZonaComunLogic();

		return zonaComunLogic.findTotalNumberZonaComun();
	}

	public static List<ZonaExtra> getZonaExtra() throws Exception {
		IZonaExtraLogic zonaExtraLogic = new ZonaExtraLogic();

		return zonaExtraLogic.getZonaExtra();
	}

	public static void saveZonaExtra(String zneCodigo, Long zneDimension,
			Long zneValor, String estCodigo_Estado,
			String inmNumeroId_Inmueble, String tzeCodigo_TipoZonaExtra)
			throws Exception {
		IZonaExtraLogic zonaExtraLogic = new ZonaExtraLogic();
		zonaExtraLogic
				.saveZonaExtra(zneCodigo, zneDimension, zneValor,
						estCodigo_Estado, inmNumeroId_Inmueble,
						tzeCodigo_TipoZonaExtra);
	}

	public static void deleteZonaExtra(String zneCodigo) throws Exception {
		IZonaExtraLogic zonaExtraLogic = new ZonaExtraLogic();
		zonaExtraLogic.deleteZonaExtra(zneCodigo);
	}

	public static void updateZonaExtra(String zneCodigo, Long zneDimension,
			Long zneValor, String estCodigo_Estado,
			String inmNumeroId_Inmueble, String tzeCodigo_TipoZonaExtra)
			throws Exception {
		IZonaExtraLogic zonaExtraLogic = new ZonaExtraLogic();
		zonaExtraLogic
				.updateZonaExtra(zneCodigo, zneDimension, zneValor,
						estCodigo_Estado, inmNumeroId_Inmueble,
						tzeCodigo_TipoZonaExtra);
	}

	public static ZonaExtra getZonaExtra(String zneCodigo) throws Exception {
		IZonaExtraLogic zonaExtraLogic = new ZonaExtraLogic();
		ZonaExtra zonaExtra = null;

		try {
			zonaExtra = zonaExtraLogic.getZonaExtra(zneCodigo);
		} catch (Exception e) {
			throw e;
		}

		return zonaExtra;
	}

	public static List<ZonaExtra> findByCriteriaInZonaExtra(Object[] variables,
			Object[] variablesBetween, Object[] variablesBetweenDates)
			throws Exception {
		IZonaExtraLogic zonaExtraLogic = new ZonaExtraLogic();

		return zonaExtraLogic.findByCriteria(variables, variablesBetween,
				variablesBetweenDates);
	}

	public static List<ZonaExtra> findPageZonaExtra(String sortColumnName,
			boolean sortAscending, int startRow, int maxResults)
			throws Exception {
		IZonaExtraLogic zonaExtraLogic = new ZonaExtraLogic();

		return zonaExtraLogic.findPageZonaExtra(sortColumnName, sortAscending,
				startRow, maxResults);
	}

	public static Long findTotalNumberZonaExtra() throws Exception {
		IZonaExtraLogic zonaExtraLogic = new ZonaExtraLogic();

		return zonaExtraLogic.findTotalNumberZonaExtra();
	}

	//Metodo que trae un usuario con el Login y password.....
	public static List<Usuario> getUsuarioParametro(String usu, String pass)
			throws Exception {
		IUsuarioLogic usuLogic = new UsuarioLogic();
		return usuLogic.getUsuarioParametro(usu, pass);
	}

	//metodo que trae el codigo del adminLocal....
	public static String getCodigoAdmin(String perCedula) throws Exception {
		IAdministradorLogic adminLog = new AdministradorLogic();
		return adminLog.getCodigoAdmin(perCedula);
	}

	//metodo que trae el codigo del propietario inmueble....
	public static String getUsuarioParametro2(String perCedula)
			throws Exception {
		IPropietarioInmuebleLogic prILogic = new PropietarioInmuebleLogic();
		return prILogic.getUsuarioParametro2(perCedula);
	}

	// metodod que llena el dataTable por Nombre de UnidadResidencial....
	public static List<UnidadResidencial> llenarTblNombUnRe(String nombUnid) throws Exception {
		IUnidadResidencialLogic uniResLogic = new UnidadResidencialLogic();
		return uniResLogic.llenarTblNombUnRe(nombUnid);
	}

	// metodod que llena el dataTable por Nit de UnidadResidencial....
	public static List<UnidadResidencial> llenarTblNITUnRe(String nit) throws Exception {
		IUnidadResidencialLogic uniResLogic = new UnidadResidencialLogic();
		return uniResLogic.llenarTblNITUnRe(nit);
	}

	//Metodo que trae las unidades del admin que este en la sesion....
	public static List<UnidadResidencial> getUnidadesAdmin(String adminCod)
			throws Exception {
		IUnidadResidencialLogic uniLog = new UnidadResidencialLogic();
		return uniLog.getUnidadesAdmin(adminCod);
	}

	 //llena el dataTable UnidaRes por NOmbre Si es Admin GLOBAL....
    public static List<UnidadResidencial> llenarDataTableUnRes(String nombConsulta)throws Exception{
    	IUnidadResidencialLogic uniResLogic = new UnidadResidencialLogic();
    	return uniResLogic.llenarDataTableUnRes(nombConsulta);
    }
    
  //llena el dataTable UnidaRes por NIT Si es Admin GLOBAL....
    public static List<UnidadResidencial> llenarDataTableUnRes2(String nit)throws Exception{
    	IUnidadResidencialLogic uniResLogic = new UnidadResidencialLogic();
    	return uniResLogic.llenarDataTableUnRes2(nit);
    }

  //metodo que llena el dataTable de autorizacion por nombre.....
    public static List<Autorizacion> consultaPorNombre_y_Usuario(String nombre, String usu) throws Exception {
		IAutorizacionLogic autorizacionlogic = new AutorizacionLogic();
    	return autorizacionlogic.consultaPorNombre_y_Usuario(nombre,usu);    	
    }
    
    //metodo que llena el dataTable de autorizacion por codigo.....
    public static List<Autorizacion> consultaPorCedula_y_Usuario(String cod, String usu) throws Exception {
		IAutorizacionLogic autorizacionlogic = new AutorizacionLogic();
    	return autorizacionlogic.consultaPorCedula_y_Usuario(cod,usu);    	
    }
    
  //Metodo que trae el numero en que van las correspondencias...
    public static String darProximoNumero() throws Exception {
    	ICorrespondenciaLogic correspondenciaLogic = new CorrespondenciaLogic();
    	String s = correspondenciaLogic.findTotalNumberCorrespondencia()+"";
         return s;
    }
    
    //Metodo que trae el numero en que van las autorizaciones...
    public static String darProximoNumeroAutorizacion() throws Exception {
    	IAutorizacionLogic autorizacionLogic = new AutorizacionLogic();
    	Long l= autorizacionLogic.findTotalNumberAutorizacion()+1;
    	String s = l+"";
         return s;
    }
    
    //Metodo que trae el numero en que van las reservas...
    public static String darNumberReserva() throws Exception {
        IReservaLogic reservaLogic = new ReservaLogic();
        Long l = reservaLogic.findTotalNumberReserva() + 1;
        return l+"";
    }
    
    //Metodo que consulta las correspondencias por Numero de Cedula para llenar el DTO...
    public static List<DtoCorrespondencia> consultarDtoCorrespondencia(String cedula) throws Exception {
    	ICorrespondenciaLogic correspondenciaLogic = new CorrespondenciaLogic();
    	return correspondenciaLogic.consultarDtoCorrespondencia(cedula);
    }
    
    //Metodo que consulta las ciudades activas...
    public static List<Ciudad> getCiudadesActivas() throws Exception {
		ICiudadLogic ciudadLogic = new CiudadLogic();
		return ciudadLogic.getCiudadesActivas();
	}    
    
    //Metodo que consulta las autorizaciones por fecha y cedula del autorizado....
    public static Autorizacion buscar(String cedula,Date fecha, String codProInm) throws Exception {
		IAutorizacionLogic autorizacionLogic = new AutorizacionLogic();
		return autorizacionLogic.buscar(cedula, fecha, codProInm);
	}
	
    
    //Metodo que consulta las reservar por fecha y zona comun....
    public static Reserva buscarReserva(String zonaComun,Date fecha, String codProInm) throws Exception {
    	IReservaLogic reservaLogic = new ReservaLogic();
		return reservaLogic. buscarReserva(zonaComun, fecha, codProInm);
	}
    
    
}
